[{"_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\": \"153be5e8a66f628c4e7a5d9bf4e85e1d9941a1ee227b692f46a1d6821a018d9f\", \"children\": [{\"_src_hash\": \"04b53efddeb02316817ec82198c8f3e4d088c8503db1891b37ed0fec619a8c59\", \"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 General Protocol}).\\n\\n### Strategy languages\\nJavaScript, Python, Rust, PINE, MyLanguage and Workflow; see {@writing-strategies/programming-languages 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 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 {@extended-api-interface/ai-integration 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\": \"0de696d347b4c79dd1664212e7aab77d9c1a09092e43365e5e8337659283dfc6\", \"desc\": [\"Six steps take you from registration to your first live robot; each step links to the details.\\n\\n### 1. Register\\n\\nRegister and log in on the [sign-up page](https://www.fmz.com/sign-up). Adding an exchange asks for your account password (the exchange keys are encrypted with it in the browser); users who log in with a third-party account and have no password yet are asked to set one first. See {@getting-started/key-security Key Security}.\\n\\n### 2. Add an exchange account\\n\\nCreate an API key on the exchange's website (enable only read and trade permissions, never withdrawal), then click \\\"Add Exchange\\\" on the [Exchange page](https://www.fmz.com/m/platforms), choose the exchange and fill in the keys. For a first try, use the exchange's demo trading or a small sub-account. For the steps and every field see {@platform-basics/exchange Exchange}.\\n\\n### 3. Deploy a docker\\n\\nThe docker is the program that runs strategies; every live robot runs on one. Rent one with a click ({@platform-basics/docker/deploy-docker/one-click-docker-rental One-Click Docker Rental}) or deploy it on your own server ({@platform-basics/docker/deploy-docker/manual-deployment-of-docker Manual Deployment of Docker}).\\n\\n### 4. Write a strategy\\n\\nOn the [new strategy page](https://www.fmz.com/m/add-strategy), choose a programming language, paste in the minimal strategy below and save. It reads the market data and the account every 5 seconds and shows them in the status bar; it does not place orders. A strategy is an entry function ```main()``` with a main loop (see {@writing-strategies/strategy-structure Strategy Structure}); all functions are listed in {@writing-strategies/api-quick-reference API Quick Reference}, and the editor is described in {@development-tools/strategy-editor Strategy Editor}. You can also start from a public strategy in the strategy square.\\n\\n### 5. Backtest\\n\\nIn the backtest panel of 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/overview-and-starting-a-backtest Overview and Starting a Backtest}.\\n\\n### 6. Create a live robot\\n\\nOn the [create robot page](https://www.fmz.com/m/add-robot), choose 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 Live Robot Billing and Top-up}. Status, logs and profit are on the robot page; see {@platform-basics/live-trading 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 \\\"Extended API Interface\\\" covers driving the platform from programs or AI assistants.\"], \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n Log(\\\"exchange:\\\", exchange.GetName(), \\\"pair:\\\", exchange.GetCurrency())\\n while (true) {\\n var ticker = exchange.GetTicker()\\n var account = exchange.GetAccount()\\n if (ticker && account) {\\n LogStatus(_D(), \\\"last:\\\", ticker.Last,\\n \\\"quote available:\\\", account.Balance, \\\"coins available:\\\", account.Stocks)\\n }\\n Sleep(5000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n Log(\\\"exchange:\\\", exchange.GetName(), \\\"pair:\\\", exchange.GetCurrency())\\n while True:\\n ticker = exchange.GetTicker()\\n account = exchange.GetAccount()\\n if ticker and account:\\n LogStatus(_D(), \\\"last:\\\", ticker[\\\"Last\\\"],\\n \\\"quote available:\\\", account[\\\"Balance\\\"], \\\"coins available:\\\", account[\\\"Stocks\\\"])\\n Sleep(5000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n Log!(\\\"exchange:\\\", exchange.GetName(), \\\"pair:\\\", exchange.GetCurrency());\\n loop {\\n if let (Ok(ticker), Ok(account)) = (exchange.GetTicker(None), exchange.GetAccount()) {\\n LogStatus!(_D(None), \\\"last:\\\", ticker.Last,\\n \\\"quote available:\\\", account.Balance, \\\"coins available:\\\", account.Stocks);\\n }\\n Sleep(5000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"Minimal runnable strategy: shows the market data and the account in the status bar every 5 seconds without placing orders; runs as is in backtesting and live trading.\"}], \"title\": \"Quick Start\"}, {\"_src_hash\": \"5e3a72aa3b5ee40f6060250a958f6d54eee2388f7e88ddde0a82669ea15e5e2f\", \"children\": [], \"desc\": \"Before configuring an exchange account, check your key settings against this list; a leaked exchange key costs you the assets in that exchange account.\\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 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 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 Common Causes of Live Trading Errors and Abnormal Exits} for what to do.\", \"title\": \"Key Security\"}], \"desc\": \"Start here: get to know the platform, go from registration to your first live robot in six steps, and keep your exchange API keys safe.\", \"title\": \"Getting Started\"}, {\"_src_hash\": \"22528ed19396439a6153dbdc174062ed040052037070a9972cf1188817042f8c\", \"children\": [{\"_src_hash\": \"2acf4d88c1f9536834131fc40d9534e45fe96ed000c1747176697342ba6f4b3a\", \"children\": [{\"_src_hash\": \"bd9f8c437a44e8477cc91e9ea4a4018e65eed5d153702960ba0d8af2c850486f\", \"children\": [], \"desc\": \"The configuration, contract codes, exchange-specific commands and notes of each exchange have moved to the \\\"Exchanges\\\" chapter of the syntax manual. Function and trading-mode command support of all exchanges is in {@exchanges/capabilities Capability Matrix}; the exchange pages are grouped under {@exchanges/cex Centralized Exchanges}, {@exchanges/dex Decentralized Exchanges}, {@exchanges/prediction Prediction Markets}, {@exchanges/broker Securities and Futures} and {@exchanges/custom On-chain & Custom}.\", \"title\": \"Exchange-Specific Notes\"}, {\"_src_hash\": \"750bacf5c6f03fa0f5f42601466b4346d1b18fab384c46247bea79455ac8ddab\", \"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: a missing file gives an error containing ```resolve key file```, and a file that exists but cannot be read gives one 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\": \"1bec8ca6b3648bdb350bda7fca766f7ec7c11f295cca366da17d2b9ddf4b2139\", \"children\": [], \"desc\": \"An exchange the platform has not integrated yet can be connected by writing a general protocol plugin: on one side the plugin calls the exchange's API, on the other it talks to the docker in a fixed format.\\n\\n![General Protocol Configuration Screenshot](/upload/asset/2e43b059b3ec9f42ded6e.png)\\n\\nAny exchange that offers a trading API can be connected this way. Plugins support 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 two kinds of plugin differ only in how they talk to the exchange API; the interaction with the docker, the data formats and other details are the same. See the examples behind the links above for implementations.\", \"title\": \"General Protocol\"}], \"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\\n### Adding an exchange account\\n\\n1. **Create an API key on the exchange**: enable only read and trade permissions, never withdrawal; if the exchange supports an IP whitelist, bind the outbound IP of the docker that will run the robot (see the checklist in {@getting-started/key-security Key Security}).\\n2. **Open the add page**: click \\\"Add Exchange\\\" on the Exchange page to open the [add exchange page](https://www.fmz.com/m/add-platform).\\n3. **Choose the protocol**: pick the exchange by category, or search by exchange name or ID. Spot and futures (contracts) are two different exchange objects and are added separately; futures exchanges carry a \\\"Futures\\\" tag. For example Binance spot is ```Binance``` and Binance futures is ```Futures_Binance```.\\n4. **Fill in the configuration**: \\\"Label\\\" is the account's name on the platform (the exchange name by default) and tells several accounts on the same exchange apart. The other fields depend on the exchange; the common ones are listed below, and the full list for each exchange is on its exchange page in the syntax manual (all exchanges are listed in {@exchanges/capabilities Capability Matrix}). Fields not marked optional are required.\\n5. **Confirm**: click the confirm button and enter your platform account password. Encrypted fields such as keys are encrypted in the browser with the account password before upload, so the platform never stores them in plain text.\\n6. **Use it**: select the exchange account when creating a live robot or a backtest. If you use the platform's public dockers, their IPs are listed at the bottom of the add page; add them to the exchange's IP whitelist.\\n\\n### Common fields\\n\\n| Field | Description |\\n| - | - |\\n| Access Key, Secret Key | The exchange API key and secret. Secret Key is an encrypted field |\\n| Passphrase | The passphrase set when creating the API key; required by some exchanges (see below) |\\n| Simulate (demo) | When checked, connects to the exchange's demo trading or testnet; usually needs a separate API key |\\n| Version, V5 protocol, V3 protocol | The exchange API version; keep the default on most exchanges |\\n| Wallet address and private keys | The wallet address, wallet private key or exchange-generated API private key used to sign on on-chain exchanges |\\n| Rpc Address, Chain, ChainType | Node address and chain for the on-chain swap and Web3 exchange objects; see {@advanced-topics/web3 Web3} |\\n| Server address, trading password | Securities and futures accounts such as Futu and Interactive Brokers; see {@exchanges/broker Securities and Futures} in the syntax manual |\\n\\n- Passphrase: required by ```OKEX``` (OKX), ```Futures_OKCoin``` (OKX futures), Bitget, DeepCoin, ```Futures_KuCoin```, ```WEEX```, ```Futures_WEEX``` and others. For ```KuCoin``` spot this field is labeled Password.\\n- Simulate (demo): supported by some exchange objects of Binance, OKX, Bybit, Gate and DigiFinex.\\n- API version: on a few exchanges the version selects the account type, for example v3 is the unified account and v2 the classic account on Bitget; see the exchange page.\\n- Wallet address and private keys: used by on-chain exchanges such as Hyperliquid, Lighter, EdgeX, Aster and Polymarket; see the exchange pages under {@exchanges/dex Decentralized Exchanges} and {@exchanges/prediction Prediction Markets} in the syntax manual for the exact fields.\\n\\nEvery masked (encrypted) input can hold a credential file path instead, so the private key stays only on the docker's machine; see {@platform-basics/exchange/local-credential-files Local Credential Files}.\\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}. ```exchange.GetName()``` returns the name of the exchange object (such as ```Futures_Binance```); the documentation uses this name when it refers to a specific exchange, with the common name in parentheses where helpful.\\n\\nStrategy code reads the account and market data, places orders and cancels them through the exchange object. In ```JavaScript```:\\n\\n```javascript\\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) // cancel the order if it is still open\\n }\\n}\\n```\", \"title\": \"Exchange\"}, {\"_src_hash\": \"38f9d729a5a12e93ae06905b5701d16ed404f9758e4894d4278b0baeafb837fa\", \"children\": [{\"_src_hash\": \"e9dc69ab98373332a1f5a611fb82db2e80aa5628cd9466d1ea8029ef8d1872f5\", \"children\": [{\"_src_hash\": \"b6a0091af4ebe5f11238f152d67e7511d51865f8543f96cedc66794c57c69164\", \"desc\": \"The platform rents a server for you and deploys the docker on it automatically, so you need no server of your own; the docker is online within a few minutes.\\n\\n### Steps\\n1. On the [docker deployment page](https://www.fmz.com/m/add-node), click the **One-Click Docker Rental** tab and choose a server by configuration and data-center region.\\n2. Click \\\"Buy Now\\\" and enter your FMZ account password to verify.\\n3. After verification the docker program is deployed and common Python libraries are installed automatically; this takes a few minutes.\\n\\n### Notes\\n- The server is rented by the platform on your behalf and has limited system permissions, with no remote login. If you need third-party Python libraries that are not pre-installed, deploy on your own server instead ({@platform-basics/docker/deploy-docker/manual-deployment-of-docker Manual Deployment of Docker}).\\n- Rented servers are billed separately from live robots.\\n- \\\"Redeploy\\\" does not delete the robot logs and data files in the ```logs``` directory of the docker.\", \"title\": \"One-Click Docker Rental\"}, {\"_src_hash\": \"856b5a72a040bf213f22840eab1a6706fb6e57ec4bf13a45cb6f1ecceb1d3d54\", \"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 # plain ./robot also loads ./robot.conf\\n```\\n\\nAll options and the configuration file format are described in {@platform-basics/docker/command-line-options 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 {@platform-basics/docker/deploy-docker/docker-operation-precautions 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 {@platform-basics/docker/command-line-options Command-Line Options} for the parameters.\", \"title\": \"Manual Deployment of Docker\"}, {\"_src_hash\": \"dbb019d91024425d886853cbb6e62480dcc03944009f109b13b7ccc105f5ece8\", \"desc\": \"What to watch out for when stopping or deleting a docker: stop the robots first, stop the docker the normal way, and avoid killing the process.\\n\\n### 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\": \"Rent a server on the platform with one click, or deploy it manually on your own device. Click **Deploy Docker** on the [docker management page](https://www.fmz.com/m/nodes) to open the [docker deployment page](https://www.fmz.com/m/add-node) and choose one.\\n\\nThe docker management page lists the dockers of your account, as a list or with details, including each docker's IP address, version and build time.\\n\\n![Docker deployment page](/upload/asset/2e527e497b3fa27ba497b.png)\", \"title\": \"Deploy Docker\"}, {\"_src_hash\": \"bd8c6384b3c65009ae3509d40767c2a933c4e36326c84040f0e34fbf65b3fdec\", \"desc\": \"Startup options of the command-line docker program ```robot``` and the format of its configuration file ```robot.conf```. Common ways to start it:\\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\\nThe address and account UID are shown on the [docker deployment page](https://www.fmz.com/m/add-node).\\n\\n### Options\\n\\n| Option | Description |\\n| --- | --- |\\n| ```-s address``` | Platform address like ```node.fmz.com/123456``` (```123456``` is the account UID); a ```ws://``` or ```wss://``` prefix is allowed. |\\n| ```-p password``` | Account password. Avoid: it stays in shell history and the process list. Omit to be prompted, or use the config 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 for both the platform connection and the strategies' exchange connections; see below. |\\n| ```-i image``` | Linux/macOS only: run each strategy process in its own container from this Docker image (Docker must be 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``` | For service wrappers: read control commands from stdin (password first if no ```-p```); ```stop``` or EOF shuts down gracefully. |\\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- A key is matched as written first and then in lower case, so only ```I``` (outbound IP) and ```i``` (Docker image) are case-sensitive; the other keys (e.g. ```S=```) work in either case.\\n- The configuration file path is resolved relative to the startup directory (before ```-w``` changes directory); ```-f @file``` is read after ```-w``` changes directory, so a relative path is resolved against the working 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\": \"8519d18805fd3ef58c099a470fb2a2f9fd1ac3e91c0ac8ddbad10f9eee385571\", \"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\": \"f8d7dd6da76aee5f41e952a0a970de38fc95bc90b9b34f925e3efffea65534b6\", \"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, when the docker goes offline abnormally and when it comes back online, the platform sends a notification according to the [push settings](https://www.fmz.com/m/account#push) (App, email, Telegram; never to the WebHook).\", \"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\\nTo put the robot directories on another disk, set the environment variable ```QUANT_ROBOT_LOG_DIR``` before starting the docker; it replaces ```logs/storage``` as the parent of the robot directories.\\n\\n### Network proxy\\nThe docker does not read the operating system's proxy settings. Environment variables such as ```HTTP_PROXY```, ```HTTPS_PROXY```, ```ALL_PROXY``` (and ```NO_PROXY```) in the docker process's environment apply to the HTTP requests a strategy makes (```HttpQuery``` and exchange REST calls), but not to WebSocket connections. To reach an exchange through a proxy, the recommended ways are:\\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.\", \"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\": \"b5cff52ac6fe2129f40bf35c8597955347fb353ddd4885596618636095e11d2a\", \"children\": [{\"_src_hash\": \"ddd33b64b304b0aecfa39d29b0665864f7653ce736fc4f215f694cbfbedca457\", \"desc\": \"Sharing a strategy gives the other user a full copy of it, source code included. Click the strategy's \\\"Share\\\" button and choose how to share in the dialog:\\n\\n- **Public Sharing**: the full strategy is shared to the platform's strategy square, where any user can copy it.\\n- **Internal Sharing**: choose a validity period and a number of uses to generate the strategy's **copy page URL** and **copy code**, and hand them to the users you choose. A user opens the copy page URL, logs in and enters the copy code to get the strategy, which then appears in their strategy library.\\n\\n![Strategy Sharing](/upload/asset/2e593d57dc36afc004ef6.png)\", \"title\": \"Strategy Sharing\"}, {\"_src_hash\": \"901206a25531b3a79395de13c5439daedd5980a75a5a1cdd4c327337880132e7\", \"desc\": \"Renting a strategy gives the other user only the right to backtest it and run it live; they cannot see the source code or other details. Click the strategy's \\\"Rent\\\" button and choose how to rent it in the dialog:\\n\\n- **Public Sale**: apply to list the strategy for sale in the strategy square; listing requires review.\\n- **Internal Sale**: choose the number of days, the maximum number of concurrent robots and the number of registration codes to generate the strategy's **registration page URL** and **registration codes**, and hand them to the users you choose. A user opens the registration page URL, logs in and enters a registration code to get the right of use; the strategy then appears in their strategy library. A maximum of 0 concurrent robots means no limit: any number of robots can be created.\\n\\n![Strategy Rental](/upload/asset/2e4e78f6c46c9dde1ce90.png)\\n\\nWhen a rented strategy expires, the robots using it are stopped and cannot be started again; once the maximum number of concurrent robots is reached, no new robot can be started.\", \"title\": \"Strategy Rental\"}], \"desc\": \"There are two ways to let others use your strategy: sharing (they get a full copy of the strategy, source code included) and renting (they get only the right to backtest and run it live, without seeing the source). On the [Strategy Library](https://www.fmz.com/m/strategies) page, click the \\\"Actions\\\" button on the right of the strategy and choose share or rent from the menu.\\n\\nWhen creating and handing out **registration codes** (rental), make sure you generated a \\\"registration code\\\" and not a \\\"copy code\\\" (sharing), so that you do not give away the source code by mistake.\", \"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 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 {@platform-basics/strategy-library/import-and-export-of-complete-strategies 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 {@platform-basics/strategy-library/strategy-sharing-and-renting Strategy Sharing and Renting}).\", \"title\": \"Strategy Library\"}, {\"_src_hash\": \"0c8f175686cff3ef9239baa0812d1504292edf60577b951d30e8a978a5be2e8b\", \"children\": [{\"_src_hash\": \"64b2568f9cfcc2eaa8fe8011af8271a3a47de2c5fbf6854ad10e66aa614de198\", \"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. For strategies, for example, you can put template libraries, JavaScript strategies and test strategies in separate groups.\\n\\nStrategy groups:\\n\\n![Strategy groups](/upload/asset/2e482ba9b9aa272085d00.png)\\n\\nRobot groups:\\n\\n![Robot groups](/upload/asset/2e577d050e817837bbfdf.png)\", \"title\": \"Grouping\"}, {\"_src_hash\": \"f453c47edee2899ffd063704478596bee1bbe87268e2feb9b704be6c44ccd468\", \"desc\": \"Click the \\\"Public\\\" button of a robot in the robot list on the [Live Trading page](https://www.fmz.com/m/robots) to let others watch it. There are two ways:\\n\\n1. **Public Sharing**: the robot is shown on the platform's public [Live Trading Observation](https://www.fmz.com/live) page.\\n2. **Internal Sharing**: set a validity period to generate a private link; whoever has the link can open the robot's private observation page.\", \"title\": \"Live Trading Observation\"}, {\"_src_hash\": \"87f27932c04957b99986730b2139ad5e306d477c28f8810a3460d3c1e82a9c97\", \"children\": [], \"desc\": \"A live robot can push log lines as messages to the mobile app, email, Telegram or a WebHook; enable the channels on the [push settings page](https://www.fmz.com/m/account#push).\\n\\n![Push Settings](/upload/asset/2e4ad17706aa842c914ce.png)\\n\\n### Push channels\\n- Mobile (App): when enabled, push messages are sent to the FMZ mobile app.\\n- Email: verify your email address first; after that you receive push messages.\\n- Telegram: bind Telegram in the push settings and enable it.\\n- WebHook: enable it and set a push address such as ```http://abc.com/push.php?data={body}```; the format is described below.\\n\\nAlerts such as docker monitoring, robot monitoring and the balance alert are also sent according to the push settings, but never to the WebHook.\\n\\n### WebHook address\\nWhen a robot sends a push message, the platform sends a ```GET``` request to the push address: ```{body}``` in the address is replaced with the message content and ```{subject}``` with the message title, both URL-encoded; ```{{body}}``` and ```{{subject}}``` are replaced as-is, without encoding.\\n\\nTo send a ```POST``` request, write the push address as ```request URL||request body```, for example ```http://abc.com/push.php||text={body}```: the part before ```||``` is the request URL and the part after it is the request body; both parts can use the placeholders above. The push address must be an ```http``` or ```https``` address reachable from the public internet.\\n\\n### Pushing from a strategy\\n- JavaScript, Python, Rust: when calling {@fun/Log/Log Log} or another function that writes to the log area (such as ```exchange.CreateOrder()``` or ```exchange.CancelOrder()```), pass one more argument ```@``` after the required ones and that log line is pushed according to the push settings, for example ```Log(\\\"This is a push message\\\", \\\"@\\\")```. In Rust use the ```Log!``` macro the same way: ```Log!(\\\"This is a push message\\\", \\\"@\\\");```.\\n- PINE and My language: enable trade log push in the parameters of the \\\"trading library\\\" built into the strategy; trades then push messages automatically.\\n\\n### Push limits\\nThe docker reports push messages with its heartbeat (about every 20 seconds), and several pushes in one cycle are merged into one; each account can push at most 50 messages per hour (a merged message counts as one), and the body of each push is at most 200 characters. The backtest system and the debugging tool do not push messages. See {@fun/Log/Log Log} for the full rules.\", \"title\": \"Live Trading Message Push\"}, {\"_src_hash\": \"0faaf64516366668314213d4c35bac37b32746d7043330e96c854360b790fa5f\", \"children\": [], \"desc\": \"When a robot will not start, reports errors or exits abnormally, check the causes below by category.\\n\\n### 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 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 looks like ```decrypt connector config (): field '': AES decrypt failed (wrong password?)``` (occasionally ```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 ```resolve key file``` (or ```read key file``` if the file exists but cannot be read). 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 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 and the exchange accounts, 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 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 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 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, when the robot exits for any reason other than a manual operation, the platform sends a notification according to the [push settings](https://www.fmz.com/m/account#push) (App, email, Telegram; never to the WebHook).\\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\\nTo let other people view and operate some of your robots, use sub-accounts (see {@platform-basics/account-and-billing/sub-accounts Sub-accounts}).\", \"title\": \"Live Trading\"}, {\"_src_hash\": \"7a5b85bf5d5a5f0d94aec2949f2c768dc5071210d137ffb53efa29acf68d0b61\", \"children\": [{\"_src_hash\": \"63f978673659ab284b2be61af83ffd717767737eaca18cc39fdd6a055c6329af\", \"desc\": \"A 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 {@extended-api-interface/extended-api-interface-details/pluginrun 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 {@extended-api-interface/ai-integration AI Integration} |\\n\\nNo robot 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 robot.\\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 {@platform-basics/trading-terminal/plugin-examples 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\": \"e0cda512d9fc82bb09d880873933410fce6bfeff10ff1b75c8dd188ee6fab582\", \"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```javascript\\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 if (!d) {\\n return 'failed to get the order book'\\n }\\n var n = Math.min(d.Asks.length, d.Bids.length, 15)\\n for (var i = 0; i < n; i++) {\\n tbl.rows.push([i, d.Asks[i].Amount, d.Asks[i].Price + '#ff0000',\\n d.Bids[i].Price + '#0000ff', d.Bids[i].Amount])\\n }\\n return tbl\\n}\\n```\\n\\n### 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```javascript\\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 if (!recordsA || !recordsB) {\\n return 'failed to get K-lines'\\n }\\n\\n var n = Math.min(recordsA.length, recordsB.length)\\n for (var i = 0; i < n; i++) {\\n var a = recordsA[recordsA.length - n + i]\\n var b = recordsB[recordsB.length - n + i]\\n chart.series[0].data.push([a.Time, a.Close - b.Close])\\n }\\n return chart\\n}\\n```\", \"title\": \"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\"}, {\"_src_hash\": \"88d3987d19eb9dcf585de4c3fcae1249e4ed59a119cc6ce1e5419b7360e976c0\", \"children\": [{\"_src_hash\": \"24414933f73cb203f4e328d47f5d8003b65cb4189058d39a54c7e7f8bea13fc3\", \"desc\": \"Live robots are billed by the hour from your platform account balance; this page covers the billing rules, bills and the balance alert, and what to watch out for when topping up.\\n\\n### 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 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, the platform sends a notification according to the [push settings](https://www.fmz.com/m/account#push) (App, email, Telegram; 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\": \"d85f9bea27aeaf33f93bbc4ff1a9f73988cd5cb1855080daaabe6e5da6affcc9\", \"desc\": \"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 view logs and charts, change strategy parameters, send interactive commands, stop and restart; it cannot change the robot's docker, strategy, version, name, exchange objects or other configuration.\\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\"}], \"desc\": \"The basic objects of the platform: exchange accounts, the docker that runs strategies, the strategy library, live robots, the trading terminal for manual trading, and account and billing.\", \"title\": \"Platform Basics\"}, {\"_src_hash\": \"66869d17e26e03436b19e725874786c42974e3ad5161770d9a8cd903cefbe2da\", \"children\": [{\"_src_hash\": \"2510f53ce0d95dbd00f32ebd5aecf1bcdbe6c537725c206503ca45a7834be028\", \"children\": [{\"_src_hash\": \"dd48c48518b439a44880b48abc839a5375ee317a64b18752a199de970bcba756\", \"desc\": \"Optional initialization function, called automatically once when the strategy starts, before ```main()```, to do initialization work.\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n Log(\\\"first line of main()\\\", \\\"#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 main()\\\", \\\"#FF0000\\\")\\n Log(\\\"exiting\\\")\\n\\n# initialization function\\ndef init():\\n Log(\\\"initializing\\\")\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n Log!(\\\"first line of main()\\\", \\\"#FF0000\\\");\\n Log!(\\\"exiting\\\");\\n}\\n\\n// initialization function\\nfn init() {\\n Log!(\\\"initializing\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"```init()``` runs before ```main()```; \\\"initializing\\\" is logged first, then the two lines from ```main()```.\"}], \"title\": \"init()\"}, {\"_src_hash\": \"de14444027cc5c7f57f87d7576fef2240c75ebe7795e077b7d883df7aadc5eca\", \"desc\": \"Optional clean-up function, called when the strategy exits to cancel orders, close positions, save state and so on. 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 Strategy Structure}.\\n\\nIn a backtest the 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; see the second example. ```Rust``` strategies need nothing special: when the backtest ends the SDK runs ```onexit()``` automatically and then stops the strategy.\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n Log(\\\"starting; stops after 5 seconds and runs the clean-up function\\\")\\n Sleep(1000 * 5)\\n}\\n\\n// clean-up function\\nfunction onexit(){\\n var beginTime = new Date().getTime()\\n while(true){\\n var nowTime = new Date().getTime()\\n Log(\\\"cleaning up, elapsed\\\", (nowTime - beginTime) / 1000, \\\"seconds\\\")\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\ndef main():\\n Log(\\\"starting; stops after 5 seconds and runs the clean-up function\\\")\\n Sleep(1000 * 5)\\n\\n# clean-up function\\ndef onexit():\\n beginTime = time.time() * 1000\\n while True:\\n ts = time.time() * 1000\\n Log(\\\"cleaning up, elapsed\\\", (ts - beginTime) / 1000, \\\"seconds\\\")\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n Log!(\\\"starting; stops after 5 seconds and runs the clean-up function\\\");\\n Sleep(1000 * 5);\\n}\\n\\n// clean-up function\\nfn onexit() {\\n let beginTime = Unix() * 1000;\\n loop {\\n let nowTime = Unix() * 1000;\\n Log!(\\\"cleaning up, elapsed\\\", (nowTime - beginTime) / 1000, \\\"seconds\\\");\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"```main()``` returns after 5 seconds; ```onexit()``` logs the elapsed time every second until it is terminated after 5 minutes.\"}, {\"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(\\\"running the clean-up function\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def 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 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(\\\"running the clean-up function\\\")\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n loop {\\n // at the end of a backtest the SDK runs onexit() first; nothing to handle here\\n match exchange.GetTicker(None) {\\n Ok(ticker) => LogStatus!(_D(None), ticker.Last),\\n Err(e) => Log!(\\\"error:\\\", e),\\n }\\n Sleep(500);\\n }\\n}\\n\\nfn main() {\\n if exchange.GetName().starts_with(\\\"Futures_\\\") {\\n Log!(\\\"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!(\\\"running the clean-up function\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"Catch the exception at the end of a backtest so that ```main()``` returns and ```onexit()``` runs.\"}], \"title\": \"onexit()\"}, {\"_src_hash\": \"530a6642c783619c202a27f0ceaa0195cbdf22612335e8c62ad46e3b1f7a6de0\", \"desc\": \"Optional exception handler, ```JavaScript``` only: 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.\\n\\nThe backtesting system does not support this function, and neither do ```Python``` and ```Rust``` strategies.\", \"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\"}], \"value\": \"An out-of-range array access in ```main()``` raises an exception, and ```onerror()``` logs the error message.\"}], \"title\": \"onerror()\"}, {\"_src_hash\": \"558e64476e945d11362b81fa1f932d7239da5ceadeed184ac05493b336386091\", \"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-limiting-control API Rate Limiting 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: run ```onTick()``` once per round, then wait 60 seconds with ```Sleep()```.\"}, {\"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\": \"Place a buy order at price 100 for amount 1 every second (a demo only; it quickly spends all funds on orders).\"}, {\"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\": \"Acting on K-line updates (On Bar): ```onTick()``` runs only when the time of the latest K-line changes.\"}], \"title\": \"Main Loop\"}, {\"_src_hash\": \"11158463b3da0598b8dc4b0830fada2f124addb1583f1f2df02d8c4658d09dfa\", \"desc\": \"Besides polling at fixed intervals, a strategy can also wait for events to arrive before processing them, which both reduces wasted requests and responds faster to market changes.\\n\\n### EventLoop\\n\\n{@fun/Threads/EventLoop EventLoop} waits for events such as the completion of concurrent tasks like ```exchange.Go()``` and ```HttpQuery_Go()```, data becoming readable on a WebSocket connection, or the receipt of a thread message; when an event occurs it returns the event information, and the strategy then reads the corresponding data. Events are only recorded from the first call to ```EventLoop()``` onward, so call ```EventLoop(-1)``` once before launching concurrent tasks:\\n\\n```javascript\\nfunction main() {\\n EventLoop(-1) // Start recording events so that none occurring afterwards are missed\\n var r1 = exchange.Go(\\\"GetTicker\\\")\\n var r2 = exchange.Go(\\\"GetDepth\\\")\\n var ev = EventLoop(1000) // Wait for any concurrent task to complete, up to 1 second\\n Log(\\\"event:\\\", ev)\\n Log(\\\"ticker:\\\", r1.wait(), \\\"depth:\\\", r2.wait())\\n}\\n```\\n\\n### ctx.subscribe / ctx.poll\\n\\nA strategy can also consume the exchange's WebSocket push feeds directly: {@fun/Threads/ctx.subscribe ctx.subscribe} subscribes to market data for a given account, the market-wide ticker feed, or the account's private stream, and returns a {@fun/Threads/Subscription Subscription} object; {@fun/Threads/ctx.poll ctx.poll} retrieves the next pushed event (with an optional wait timeout), and the strategy handles each event according to its ```channel```. ```JavaScript``` and ```Python``` strategies use the global ```ctx``` object; ```Rust``` strategies use the functions of the same name in the ```ctx``` module.\\n\\n```javascript\\nfunction main() {\\n // The first argument is the exchange object; if no symbol is given, its current trading pair is used\\n var tk = ctx.subscribe(exchange, {channel: \\\"ticker\\\"})\\n var book = ctx.subscribe(exchange, {channel: \\\"depth\\\", depth: 20}) // 20-level order book\\n // Account private stream: order updates, positions and balances are all pushed through this one feed\\n var acct = ctx.subscribe(exchange, {channel: \\\"private\\\"})\\n while (true) {\\n const ev = ctx.poll([], 1000) // [] means all subscriptions of this thread; wait up to 1 second\\n if (!ev) {\\n continue\\n }\\n if (ev.type === \\\"status\\\") { // Handle gateway status and subscription status events separately first\\n if (ev.kind === 35 && ev.prefillStatus === 2) {\\n Log(\\\"subscription failed:\\\", ev.channel, ev.message)\\n }\\n continue\\n }\\n if (ev.channel === \\\"ticker\\\") {\\n Log(\\\"ticker:\\\", ev.symbol, ev.bid, ev.ask, ev.last)\\n } else if (ev.channel === \\\"depth\\\") {\\n // Depth events carry no level data; read it from this subscription's own order book\\n const b = ev.book(1)\\n if (b.bids.length > 0 && b.asks.length > 0) {\\n Log(\\\"bid1:\\\", b.bids[0][0], \\\"ask1:\\\", b.asks[0][0])\\n }\\n } else if (ev.channel === \\\"orders\\\") {\\n Log(\\\"order:\\\", ev.id, ev.state, ev.filledQty)\\n } else if (ev.channel === \\\"positions\\\" || ev.channel === \\\"balance\\\") {\\n Log(\\\"positions:\\\", acct.positions(), \\\"balances:\\\", acct.balances())\\n }\\n }\\n}\\n```\\n\\n```Python``` works the same way: options are a dict, and events are dicts too (attribute access such as ```ev.kind``` also works):\\n\\n```python\\ndef main():\\n tk = ctx.subscribe(exchange, {\\\"channel\\\": \\\"ticker\\\"})\\n book = ctx.subscribe(exchange, {\\\"channel\\\": \\\"depth\\\", \\\"depth\\\": 20})\\n acct = ctx.subscribe(exchange, {\\\"channel\\\": \\\"private\\\"})\\n while True:\\n ev = ctx.poll([], 1000) # Returns None on timeout\\n if ev is None:\\n continue\\n if ev.type == \\\"status\\\":\\n if ev.kind == 35 and ev.prefillStatus == 2:\\n Log(\\\"subscription failed:\\\", ev.channel, ev.message)\\n continue\\n if ev.channel == \\\"ticker\\\":\\n Log(\\\"ticker:\\\", ev.symbol, ev.bid, ev.ask, ev.last)\\n elif ev.channel == \\\"depth\\\":\\n b = ev.book(1)\\n if b[\\\"bids\\\"] and b[\\\"asks\\\"]:\\n Log(\\\"bid1:\\\", b[\\\"bids\\\"][0][0], \\\"ask1:\\\", b[\\\"asks\\\"][0][0])\\n elif ev.channel == \\\"orders\\\":\\n Log(\\\"order:\\\", ev.id, ev.state, ev.filledQty)\\n elif ev.channel in (\\\"positions\\\", \\\"balance\\\"):\\n Log(\\\"positions:\\\", acct.positions(), \\\"balances:\\\", acct.balances())\\n```\\n\\n- The first argument is the exchange object (```exchange```, ```exchanges[1]```) or the account's index in ```exchanges```; the second argument is the options object ```{channel, symbol, depth, interval, mode, buffer}```, with the instrument specified in ```symbol```.\\n- ```channel``` can be ```ticker```, ```bbo```, ```depth``` (```depth``` is the number of levels), ```trade```, ```kline``` (```interval``` is the candlestick period in seconds), ```tickers``` or ```private```. ```private``` takes no instrument; order updates, positions and balances are all pushed through this one feed, and the corresponding events have ```channel``` set to ```orders```, ```positions``` and ```balance``` respectively. After subscribing, an account snapshot is pushed first; once it is ready, the latest positions and balances can be obtained via the subscription object's ```positions()``` and ```balances()```.\\n- ```tickers``` takes no instrument; a single subscription receives tickers for every instrument on the exchange, and the event's ```symbol``` is the corresponding instrument. Only exchanges that provide a market-wide push feed support this channel; see the \\\"Push\\\" column of the {@exchanges/capabilities capability matrix} for details. When it is not supported, the subscription receives a failed status event.\\n- When ```symbol``` is an array, multiple instruments are subscribed at once and an array of subscription objects is returned in the same order: the whole batch is validated first, and if any instrument is invalid, nothing in the batch is subscribed. The array can be passed directly to ```ctx.poll()```, and calling the array's ```unsubscribe()``` unsubscribes all of them at once.\\n- Every event contains fields such as ```stream``` (the ```id``` of the subscription it belongs to), ```type``` and ```channel```; see {@fun/Threads/ctx.poll ctx.poll} for field details. A depth event only signals that the order book has been updated; the level data must be read via ```ev.book(n)``` or the subscription object's ```book(n)```.\\n- Identical subscriptions share a single push feed. To unsubscribe, call the subscription object's ```unsubscribe()```; the subscription is actually cancelled only when the last subscription object unsubscribes. A subscription that the exchange does not support does not throw an exception; instead, that subscription receives a status event with ```prefillStatus``` set to ```2```.\\n- If market data subscriptions are not consumed promptly, only the latest data is kept or the oldest data is dropped; order updates, positions and balances are never dropped. The strategy must keep calling ```ctx.poll()```. To check whether events are being processed in time, look at the ```feed``` counters for each exchange in ```ctx.connectors()```.\\n- Push feeds and REST interfaces are independent of each other: functions such as ```exchange.GetTicker()``` and ```exchange.GetDepth()``` still call the exchange's REST API on every request and do not read push data. See the respective exchange pages for the push channels each exchange supports.\\n- In ```JavaScript``` and ```Rust```, ```EventLoop()``` and ```ctx.poll()``` in the same thread take events from the same event queue, so a thread should use only one of them; in ```Python```, ```EventLoop()``` has its own separate queue and does not compete with ```ctx.poll()```.\\n\\nA subscription belongs to the thread that called ```ctx.subscribe()```: events are delivered only to that thread, ```ctx.poll()``` only retrieves events for the current thread's subscriptions, and only that thread can unsubscribe. To dedicate a thread to a set of market data, subscribe within that thread; when different threads subscribe to the same content, the exchange side is subscribed only once, but each thread receives its own copy:\\n\\n```javascript\\nfunction main() {\\n var t = threading.Thread(function(symbols) {\\n var subs = ctx.subscribe(0, {channel: \\\"depth\\\", symbol: symbols, depth: 5})\\n while (true) {\\n var ev = ctx.poll([], 1000) // Only the two feeds subscribed by this thread\\n if (ev && ev.kind === 3) {\\n var b = ev.book(1)\\n if (b.bids.length > 0 && b.asks.length > 0) {\\n Log(ev.symbol, \\\"bid1:\\\", b.bids[0][0], \\\"ask1:\\\", b.asks[0][0])\\n }\\n }\\n }\\n }, [\\\"ETH_USDT\\\", \\\"SOL_USDT\\\"])\\n var acct = ctx.subscribe(0, {channel: \\\"private\\\"}) // The main thread handles only the account private stream\\n while (true) {\\n var ev = ctx.poll([acct], 1000)\\n if (ev && ev.kind === 16) {\\n Log(\\\"order:\\\", ev.id, ev.state)\\n }\\n }\\n}\\n```\\n\\n```Python``` creates threads with the standard library's ```threading.Thread``` and works the same way; when a thread ends, its subscriptions are unsubscribed automatically.\\n\\nIn ```Rust``` strategies, the calls are ```ctx::subscribe()``` and ```ctx::poll()```; subscription options are built with ```ctx::SubOpts```, batch subscriptions use ```ctx::subscribe_many()```, and any thread can subscribe. Events are raw structs; after importing ```sdk::ctx::EventExt```, methods such as ```ev.channel()```, ```ev.book(n)```, ```ev.ticker()```, ```ev.order()``` and ```ev.feed_status()``` read them according to event type (prices and quantities are already converted to real numbers, so no ```unsafe``` code is needed):\\n\\n```rust\\nuse sdk::ctx::EventExt;\\n\\nfn main() {\\n let book = ctx::subscribe(exchange, ctx::SubOpts::depth(20)).unwrap();\\n loop {\\n match ctx::poll(&[book.id()], Some(1000)) {\\n ctx::Polled::Event(ev) => {\\n if let Ok(b) = ev.book(1) {\\n if !b.bids.is_empty() && !b.asks.is_empty() {\\n Log!(\\\"bid1:\\\", b.bids[0].0, \\\"ask1:\\\", b.asks[0].0);\\n }\\n }\\n }\\n ctx::Polled::Stopped => break,\\n _ => {}\\n }\\n }\\n}\\n```\", \"title\": \"Event-Driven\"}], \"desc\": \"Strategies in ```JavaScript```, ```Python``` and ```Rust``` consist of a few functions with agreed names, which the docker calls at fixed points. MyLanguage, PINE 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); then ```onexit()``` is not called. |\\n| ```destroy()``` | No | ```JavaScript``` template libraries only: called when the strategy exits, after ```onexit()``` or ```onerror()```; see {@writing-strategies/template-library 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 and ```JavaScript``` and ```Python``` strategies do not run ```onexit()```; see {@writing-strategies/strategy-structure/onexit onexit()} for how to handle this. ```Rust``` strategies run ```onexit()``` automatically when the backtest ends.\\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 {@writing-strategies/strategy-structure/main-loop Main Loop}). A strategy can also wait for market data, order updates and other events and handle them as they arrive (see {@writing-strategies/strategy-structure/event-driven Event-driven handling}). For a categorized list of all API functions see {@writing-strategies/api-quick-reference API Quick Reference}.\", \"title\": \"Strategy Structure\"}, {\"_src_hash\": \"a1818f9fc4a145b510de594a3de29671e36f1c69988b17f0dd3c5965ffbaacc2\", \"children\": [{\"_src_hash\": \"ecd313bbc6a763a38a6320c5bd32756b01d37a5d1219f303056951b4880413a9\", \"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. Strategies can also be written in TypeScript; see \\\"Writing in TypeScript\\\" at the end of this page.\\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 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 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```javascript\\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```javascript\\nfunction stringToHex(str) {\\n let hex = ''\\n for (let i = 0; i < str.length; i++) {\\n const charCode = str.charCodeAt(i).toString(16)\\n hex += charCode.length === 1 ? '0' + charCode : charCode\\n }\\n return hex\\n}\\n\\nfunction main() {\\n // 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-multi-threading JavaScript Multi-threading}).\\n\\n```javascript\\nasync function main() {\\n let resp = await fetch(\\\"https://www.okx.com/api/v5/market/books?instId=BTC-USDT\\\")\\n if (resp.ok) {\\n Log(resp.json())\\n } else {\\n Log(\\\"status:\\\", resp.status)\\n }\\n}\\n```\\n\\n### Libraries and dependencies\\n\\nJavaScript strategies can use the built-in ```TA``` and ```talib``` indicator libraries directly; see {@writing-strategies/built-in-libraries 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.\\n\\n### Writing in TypeScript\\n\\nTypeScript is not a separate language option. Create the strategy as ```JavaScript``` and put a ```//@ts-check``` comment line in the code (usually the first line), 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 {@extended-api-interface/ai-integration AI Integration}).\\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. Static type checking catches mistakes such as wrong argument counts, property names or types while you write. Language features, APIs and libraries at run time are the same as for JavaScript.\\n\\n```typescript\\n//@ts-check\\nfunction getSignal(ticker: ITicker, ma: number): \\\"buy\\\" | \\\"sell\\\" | null {\\n if (ticker.Last > ma) {\\n return \\\"buy\\\"\\n }\\n return ticker.Last < ma ? \\\"sell\\\" : null\\n}\\n\\nfunction main() {\\n const records = exchange.GetRecords()\\n const ticker = exchange.GetTicker()\\n if (records && ticker && records.length > 20) {\\n const ma = TA.MA(records, 20)\\n Log(getSignal(ticker, ma[ma.length - 1]))\\n }\\n}\\n```\", \"title\": \"JavaScript\"}, {\"_src_hash\": \"5fbd1f03adaaf7090a075298d9db1358223c0ff4f17900632482720e672025f1\", \"desc\": \"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\\nFor live trading the docker looks for an interpreter in this order and uses the first program that starts and is Python 3:\\n1. the interpreter named on the strategy's first line after ```#!```, for example ```#!/opt/venv/bin/python3```; with ```#!/usr/bin/env python3.11``` it takes ```python3.11```;\\n2. the interpreter given by the environment variable ```PYTHON_BIN```;\\n3. ```python3```;\\n4. ```python```.\\n\\nIf the interpreter named on the first line cannot be used, the docker falls back to the next candidates and leaves a note in ```stderr.log``` in the live trading directory. To choose an interpreter without changing the strategy code (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\\nBacktests that run on a docker do not read ```PYTHON_BIN```: they search ```PATH``` for the first program that exists, in the order: the interpreter named after ```#!```, ```python3```, ```python```.\\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 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()``` is written to ```logs/storage//stdout.log``` under the docker's directory (error output goes to ```stderr.log``` in the same directory) 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 the first line names an interpreter with #!, install with that one, e.g.\\n/opt/venv/bin/python3 -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 is the live trading directory ```logs/storage//``` (files opened with relative paths land there and are kept with the live trading); ```PYTHONPATH``` is a temporary directory created by the docker for that run and deleted afterwards. The current directory is not on the module search path, so ```.py``` files placed in the live trading directory 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\": \"edb4e8a99eec3249791e01fc67b9c47df36121ef1aa81345896cc2a19215d3c2\", \"desc\": \"Strategies can be written in ```Rust```. Rust strategies are compiled before they run: for backtesting the platform server compiles them and they are backtested in the cloud (on the platform's servers) by default, or in the browser if you choose the \\\"Local\\\" backtest node; 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 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 or lines starting with ```#!``` 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 Built-in Libraries}.\", \"title\": \"Rust\"}, {\"_src_hash\": \"19312a76d3c8aab2d7fec9a25424f28a38b4674e6c772a6affe8db787e0a3371\", \"desc\": \"Strategies can be written in MyLanguage, which is compatible with most of the syntax, instructions and functions of Wenhua MyLanguage. It breaks complex algorithms into functions and describes trading logic with a concise syntax and a library of financial functions.\\n\\nExample strategy: a 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// A trend-following strategy for larger periods such as daily K-lines.\\n// This model is only an example of model development; trade on it at 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\": \"5b0c1192e440940a32a3ea0a103460e4216a10b025646679351662ec8405fa8b\", \"desc\": \"The platform supports ```Trading View```'s PINE language scripts. PINE is used to write indicators and strategies that can be backtested and traded live; the community has published more than 100,000 PINE scripts that you can reuse to implement your own trading ideas instead of starting from scratch.\\n\\nExample strategy: Supertrend\\n\\n```pine\\nstrategy(\\\"supertrend\\\", overlay=true)\\n\\n[supertrend, direction] = ta.supertrend(input(5, \\\"factor\\\"), input.int(10, \\\"atrPeriod\\\"))\\nplot(direction < 0 ? supertrend : na, \\\"Up direction\\\", color = color.green, style=plot.style_linebr)\\nplot(direction > 0 ? supertrend : na, \\\"Down direction\\\", color = color.red, style=plot.style_linebr)\\n\\nif direction < 0\\n if supertrend > supertrend[2]\\n strategy.entry(\\\"entry long\\\", strategy.long)\\n else if strategy.position_size < 0\\n strategy.close_all()\\nelse if direction > 0\\n if supertrend < supertrend[3]\\n strategy.entry(\\\"entry short\\\", strategy.short)\\n else if strategy.position_size > 0\\n strategy.close_all()\\n```\\n\\n- [PINE Script Documentation](https://www.fmz.com/bbs-topic/9315)\", \"title\": \"PINE Language\"}, {\"_src_hash\": \"42362f0a14ffde529345050b607e3b66fb63083e7b8e3d30be88a3efbd0750aa\", \"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\": \"Strategies can be written in ```JavaScript```, ```Python```, ```Rust```, [```PINE```](https://www.fmz.com/bbs-topic/9315), [```My Language```](https://www.fmz.com/bbs-topic/2569) (MyLanguage) and the ```Workflow``` visual editor.\\n\\n```JavaScript```, ```Python``` and ```Rust``` strategies call the platform's full API directly; PINE and My Language follow the script syntax of TradingView and Wenhua; Workflow builds a strategy from visual nodes without writing code.\", \"title\": \"Programming Languages\"}, {\"_src_hash\": \"d0232e55f657b4b6eff7d4528e4fc751e81981861b35f61ccec3c1f8d45a9ce0\", \"children\": [{\"_src_hash\": \"582c9c6a4cf9e0c8ff75a135fa64bc9fccca598c735988566844fe6b35255218\", \"desc\": \"Interface parameters are set in the strategy parameters area below the code editor on the strategy editing page. There are 5 types; the variable names in the table are only examples:\\n\\n| Type | Example variable | Value in code | Default value |\\n| - | - | - | - |\\n| Number (number) | ```pNum``` | A number; ```f64``` in Rust | Enter a number, e.g. ```100``` |\\n| Boolean (true/false) | ```pBool``` | A boolean | Set with a switch; cannot be optional |\\n| String (string) | ```pStr``` | A string | Type it as is, e.g. ```abc```, without quotes |\\n| Dropdown (selected) | ```pCombox``` | Index or bound data of the selected option; an array with multiple selection | Select one or more options |\\n| Encrypted string (string) | ```pSecretStr``` | A string | Type it as is, e.g. ```xyz```, without quotes |\\n\\n### Settings of a parameter\\n- Variable: the name of the parameter's global variable in the strategy code; do not use a reserved word (keyword) of the programming language.\\n- Description: the display name of the control bound to the parameter.\\n- Remarks: the tooltip shown when the mouse hovers over the parameter's control in the backtest or live robot interface.\\n- Default value and \\\"Optional\\\": the \\\"Optional\\\" switch next to the default value is on by default and can be turned off to make the parameter required. A backtest or live robot cannot start if a required parameter is not set.\\n- Component configuration: the type of UI control bound to the parameter, plus minimum, maximum, group, filter and so on; see {@writing-strategies/strategy-parameters/component-configuration Component Configuration}.\\n\\n### Notes\\n- Parameters are global variables in the code and can be modified there (except in Rust, where parameters are global constants and cannot be modified).\\n- An \\\"Encrypted string\\\" parameter is used the same way as a \\\"String\\\" parameter, but it is sent encrypted, never in plain text.\\n- An optional parameter that is left empty is an empty string for String parameters, and a null value for Number, Dropdown and Encrypted string parameters. In ```Rust``` strategies it is the zero value of its type: ```0``` for numbers, an empty string for strings and encrypted strings, ```false``` for booleans.\\n- A dropdown parameter without \\\"Support multiple selection\\\" in its component configuration holds the index of the selected option, or the option's bound data if data is bound; with \\\"Support multiple selection\\\" it holds an array of the indices (or bound data) of all selected options.\", \"title\": \"Interface Parameter Types\"}, {\"_src_hash\": \"644d4b1599e143e3633d6f2e67f51ceac15ef5a2e6e0897987ad32f8330adf8e\", \"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 available for each type (the first one is the default):\\n\\n| Type | Components |\\n| - | - |\\n| Number (number) | Input box, time picker, slider |\\n| Boolean (true/false) | Switch |\\n| String (string) | Input box, text box, time picker, color picker, currency, trading symbol |\\n| Dropdown (selected) | Dropdown, segmented control, currency, trading symbol |\\n| Encrypted string (string), strategy parameters only | Encrypted input box |\\n| Button (button), interactive controls only | Button (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). The filter is empty by default, meaning no filtering; the parameter is available when the condition is true. Expressions such as ```a > b```, ```a == 1```, ```a```, ```!a``` and ```a >= 1 && a <= 10``` can be used, for example:\\n- ```a == 1```: available when parameter ```a``` equals 1, otherwise not.\\n- ```a >= 1 && a <= 10```: available when ```a``` is at least 1 and at most 10, otherwise not.\\n- ```!a```: the condition is \\\"not a\\\"; ```a``` can be a boolean or a number (```!0``` is true).\", \"title\": \"Component Configuration\"}, {\"_src_hash\": \"e2a31579cba1c1fe5321e127f68ae783b975fca1039ac58f58c08a8918e2c1e5\", \"desc\": \"Strategy parameters set for a backtest can be saved into the strategy code; a live robot's parameters can be exported to a file and imported into another robot.\\n\\n### Saving backtest parameters\\nAfter changing strategy parameters on the backtest page, click \\\"Save Backtest Settings\\\": the parameters are saved together with the backtest configuration as a comment block at the top of the strategy code; see {@backtesting-system/backtest-configuration-and-saving Backtest Configuration and Saving}. For example, for a strategy with these parameters:\\n\\n| Variable | Description | Type | Default |\\n| - | - | - | - |\\n| number | Number | Number (number) | 1 |\\n| string | String | String (string) | Hello FMZ |\\n| combox | Dropdown | Dropdown (selected) | 1\\\\|2\\\\|3 |\\n| bool | Boolean | Boolean (true/false) | true |\\n| numberA | Number A (filter ```isShowA```: available only when ```isShowA``` is true) | Number (number) | 2 |\\n| isShowA | Whether to show numberA | Boolean (true/false) | false |\\n\\nafter changing the values and saving, the block at the top of the code looks like this (```JavaScript``` and ```Rust``` use ```/*backtest ... */```, ```Python``` uses ```'''backtest ... '''```):\\n\\n```javascript\\n/*backtest\\nstart: 2020-02-29 00:00:00\\nend: 2020-03-29 00:00:00\\nperiod: 1d\\nargs: [[\\\"number\\\",2],[\\\"string\\\",\\\"Hello\\\"],[\\\"combox\\\",2],[\\\"bool\\\",false],[\\\"numberA\\\",666],[\\\"isShowA\\\",true]]\\n*/\\n```\\n\\n```python\\n'''backtest\\nstart: 2020-02-29 00:00:00\\nend: 2020-03-29 00:00:00\\nperiod: 1d\\nargs: [[\\\"number\\\",2],[\\\"string\\\",\\\"Hello\\\"],[\\\"combox\\\",2],[\\\"bool\\\",false],[\\\"numberA\\\",666],[\\\"isShowA\\\",true]]\\n'''\\n```\\n\\nIf a ```Rust``` strategy declares dependencies in a frontmatter block at the top, the backtest configuration block must come after the frontmatter; see {@writing-strategies/programming-languages/rust Rust}.\\n\\n### Importing and exporting live robot parameters\\n1. On the robot page, click \\\"Parameter Settings\\\", then \\\"Export Parameters\\\"; the parameters are saved as a ```json``` file.\\n2. On the robot page that should receive them, click \\\"Import Parameters\\\" and choose the exported file.\\n3. Click \\\"Update Parameters\\\" to save; the imported parameters take effect only then.\", \"title\": \"Save Parameter Settings\"}], \"desc\": \"Set in the strategy interface; they appear in the strategy code as global variables with the same names (global constants in Rust), accessed by name. Differences between languages:\\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 {@writing-strategies/programming-languages/rust Rust} for the type of each kind of parameter.\\n- ```PINE```: interface parameters are created with the ```input()``` function.\\n\\n![Strategy Parameter Settings Interface](/upload/asset/2e46b5e593de3b2f11445.png)\", \"title\": \"Strategy Parameters\"}, {\"_src_hash\": \"272de84678d5c2e1bd8888206393a8529070bd9090e6f61461c76d95e30be569\", \"children\": [{\"_src_hash\": \"ad5a29d99ea52313b426151280145c99eea54eea28a6f6633bcc171a3f6db20c\", \"desc\": \"There are 5 types of interactive control. When the control's button is clicked, {@fun/Global/GetCommand GetCommand} in the strategy receives a string message. The variable names in the table are only examples:\\n\\n| Type | Example variable | Default value | Message received by ```GetCommand()``` |\\n| - | - | - | - |\\n| Number (number) | ```cmdNum``` | Optional, may be empty | Enter ```123``` and click: ```cmdNum:123``` |\\n| Boolean (true/false) | ```cmdBool``` | Required, on or off | Click with the switch on: ```cmdBool:true``` |\\n| String (string) | ```cmdStr``` | Optional, may be empty | Enter ```abc``` and click: ```cmdStr:abc``` |\\n| Dropdown (selected) | ```cmdCombox``` | Optional, may be empty | Pick option 2 and click: ```cmdCombox:1``` (index from 0) |\\n| Button (button) | ```cmdBtn``` | No input | Click: ```cmdBtn``` |\\n\\nThe message format is ```variable:value```; a button sends only its variable name. Description, remarks and component configuration of interactive controls work as for strategy parameters; see {@writing-strategies/strategy-parameters/interface-parameter-types Interface Parameter Types} and {@writing-strategies/strategy-parameters/component-configuration 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```javascript\\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\": \"4a06aedfaad439cc23d3eddd4798243a221d3853e58ada0f68170ed239a5b753\", \"desc\": \"Besides the controls designed in the \\\"Strategy Interaction\\\" section, a strategy can output interactive controls in its status bar. The only interactive control there is the button. For all fields of buttons and input controls, and the format of the command that {@fun/Global/GetCommand GetCommand} receives after a click, see \\\"Status bar buttons\\\" on the {@fun/Log/LogStatus LogStatus} page; this page shows the common patterns.\\n\\nThere are three kinds of status bar buttons:\\n- A plain button: a click opens a confirmation box, and on confirmation the strategy receives ```cmd```.\\n ```json\\n {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"平仓|Close\\\", \\\"cmd\\\": \\\"close\\\",\\n \\\"description\\\": \\\"平掉全部持仓|close all positions\\\"}\\n ```\\n- A button with one input control: set it with ```input```; the strategy receives ```cmd:value```.\\n ```json\\n {\\n \\\"type\\\": \\\"button\\\",\\n \\\"name\\\": \\\"开仓|Open\\\",\\n \\\"cmd\\\": \\\"open\\\",\\n \\\"input\\\": {\\\"type\\\": \\\"number\\\", \\\"name\\\": \\\"amount\\\", \\\"label\\\": \\\"开仓数量|amount\\\",\\n \\\"default\\\": 1, \\\"required\\\": true}\\n }\\n ```\\n- A button with a group of input controls: set them with ```group```; the strategy receives ```cmd:JSON``` keyed by each control's ```name```. In this example the price control is shown only when the order type is \\\"limit\\\":\\n ```json\\n {\\n \\\"type\\\": \\\"button\\\",\\n \\\"cmd\\\": \\\"order\\\",\\n \\\"name\\\": \\\"下单|Order\\\",\\n \\\"group\\\": [\\n {\\\"type\\\": \\\"selected\\\", \\\"name\\\": \\\"orderType\\\", \\\"label\\\": \\\"下单方式|order type\\\", \\\"default\\\": 0,\\n \\\"settings\\\": {\\\"options\\\": [\\\"市价单|market\\\", \\\"限价单|limit\\\"]}},\\n {\\\"type\\\": \\\"number\\\", \\\"name\\\": \\\"price\\\", \\\"label\\\": \\\"价格|price\\\",\\n \\\"settings\\\": {\\\"filter\\\": \\\"orderType==1\\\"}},\\n {\\\"type\\\": \\\"number\\\", \\\"name\\\": \\\"amount\\\", \\\"label\\\": \\\"数量|amount\\\", \\\"default\\\": 1,\\n \\\"required\\\": true}\\n ]\\n }\\n ```\\n\\nWhen writing these controls:\\n- Put the display condition in ```settings.filter``` (for example ```\\\"filter\\\": \\\"orderType==1\\\"```), referring to the ```name``` of another control in the same group; a ```filter``` at the top level of the control has no effect.\\n- Put ```\\\"required\\\": true``` at the top level of the control; a ```required``` inside ```settings``` has no effect.\\n- Each line of the status bar can hold only one JSON block wrapped in ``` ` ```. Output several buttons on separate lines, or put them in a status bar table (several buttons in one cell are written as an array of buttons).\\n- Texts can be bilingual, written as ```\\\"中文|English\\\"``` and shown according to the page language.\\n\\nTo output a button, encode the button object as a JSON string, wrap it in ``` ` ``` and pass it to ```LogStatus()```. In JavaScript:\\n\\n```javascript\\nfunction main() {\\n var btnClose = {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"平仓|Close\\\", \\\"cmd\\\": \\\"close\\\"}\\n var btnOpen = {\\n \\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"开仓|Open\\\", \\\"cmd\\\": \\\"open\\\",\\n \\\"input\\\": {\\\"type\\\": \\\"number\\\", \\\"name\\\": \\\"amount\\\", \\\"label\\\": \\\"开仓数量|amount\\\", \\\"default\\\": 1}\\n }\\n // one JSON block per line: the two buttons go on two lines\\n LogStatus(\\\"`\\\" + JSON.stringify(btnClose) + \\\"`\\\\n`\\\" + JSON.stringify(btnOpen) + \\\"`\\\")\\n while (true) {\\n var cmd = GetCommand()\\n if (cmd) {\\n Log(\\\"command received:\\\", cmd) // \\\"close\\\", \\\"open:2\\\"\\n }\\n Sleep(1000)\\n }\\n}\\n```\\n\\nFor buttons in status bar tables, button colors and sizes (```class```), multi-select and customizable drop-downs, sliders, date pickers and other control styles, see {@fun/Log/LogStatus LogStatus}.\\n\\n### Status bar display components\\n\\nBesides text, tables and buttons, {@fun/Log/LogStatus LogStatus} accepts objects with a `type` directly and the status bar renders them as components: `grid` and `tabs` handle layout, while `kpi` (KPI card), `stat` (key-value list), `chart` (line, bar and area charts), `sparkline`, `gauge`, `progress`, `pie`, `histogram`, `heatmap`, `calendar`, `timeline`, `markdown`, `alert` and `badge` display data. Components are display-only and can share a `grid` with buttons and tables:\\n\\n```javascript\\nfunction main() {\\n var btn = {type: \\\"button\\\", name: \\\"平仓|Close\\\", cmd: \\\"close\\\"}\\n while (true) {\\n var ticker = exchange.GetTicker()\\n if (ticker) {\\n LogStatus({type: \\\"grid\\\", cols: 2, items: [\\n {type: \\\"kpi\\\", title: \\\"Last price\\\", value: ticker.Last},\\n btn // no backticks needed for a button inside a grid\\n ]})\\n }\\n var cmd = GetCommand()\\n if (cmd) {\\n Log(\\\"Command received:\\\", cmd)\\n }\\n Sleep(1000)\\n }\\n}\\n```\\n\\nFor the fields of every component and examples in three languages see {@struct/OtherStruct/LogStatus-display Status Bar Components}; for the input forms (objects, backticks, several arguments) see {@fun/Log/LogStatus LogStatus}.\", \"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 {@writing-strategies/strategy-parameters/component-configuration 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\": \"133ba430c45ba605bc3bafec6f13b27f37368c87ddc801288180ac48f35fffc7\", \"children\": [{\"_src_hash\": \"701e5bd7639104e25ac4fec9c0f944b43f9ab3c755c0b5a10c29662d142a59d5\", \"desc\": \"Exported functions are the interface a template library offers; strategies that reference the template library can call them. How each language exports them is described in {@writing-strategies/template-library Template Library}.\", \"examples\": [{\"examples\": [{\"code\": \"/*\\n-- after referencing this template, a strategy calls this method directly as $.Test()\\n-- main is never triggered in the strategy; it is only the entry point for debugging the template\\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# export Test; the main strategy calls it as 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\": \"Declare and implement the exported function ```Test``` in a template library, in each language.\"}], \"title\": \"Export Functions of Template Libraries\"}, {\"_src_hash\": \"be30af4657cee374b511e85eb782c8e8c1f909be978542b4c738781072f6f555\", \"desc\": \"Template libraries can also set their own interface parameters. Template library parameters are used as global variables in the template library code (global constants in Rust). For example, a template library with this 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\\nIn the examples below the template exports functions that read and modify the parameter, and the strategy calls them. Parameters of a ```Rust``` template are constants that can only be read, not modified, so in Rust the parameter can only be read:\\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\"}], \"value\": \"Template library code: export functions that read and modify 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\"}], \"value\": \"Strategy code that references the template above: read and modify ```param1``` through the exported functions.\"}], \"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 reusable code module on the FMZ Quant Trading Platform and a category of strategy code. Languages that support template libraries: ```JavaScript```, ```Python``` and ```Rust```. 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\": \"682537dcabc3bebd13d952ef41f83c251aa351a300b2f935d4bd8370149eee7c\", \"children\": [], \"desc\": \"Strategies can use the platform's built-in ```TA``` and ```talib``` indicator libraries and each language's JSON support without importing anything. Availability by language:\\n\\n| Library | JavaScript | Python | Rust |\\n| - | - | - | - |\\n| ```TA``` indicators | ✓ | ✓ | ✓ |\\n| ```talib``` indicators | ✓ | ✓ (needs TA-Lib and numpy on the docker's machine) | ✗ |\\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```javascript\\nfunction main(){\\n var records = exchange.GetRecords()\\n if (!records) {\\n return\\n }\\n var macd = TA.MACD(records)\\n var atr = TA.ATR(records, 14)\\n\\n // 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```javascript\\nfunction main() {\\n var records = exchange.GetRecords()\\n if (!records) {\\n return\\n }\\n var cci = talib.CCI(records, 14)\\n Log(cci)\\n}\\n```\\n\\n```python\\n# needs TA-Lib and numpy on the docker's machine, otherwise talib raises an error\\ndef main():\\n records = exchange.GetRecords()\\n if not records:\\n return\\n cci = talib.CCI(records.High, records.Low, records.Close, 14)\\n Log(cci)\\n```\\n\\n### JavaScript: loading third-party libraries dynamically\\n\\nOther third-party JavaScript libraries can be downloaded at run time and loaded with ```eval```:\\n\\n```javascript\\nfunction main() {\\n // via. https://cdnjs.com/libraries\\n eval(HttpQuery(\\\"https://cdnjs.cloudflare.com/ajax/libs/mathjs/13.2.0/math.min.js\\\"))\\n\\n Log(math.round(math.e, 3)) // 2.718\\n Log(math.atan2(3, -3) / math.pi) // 0.75\\n Log(math.log(10000, 10)) // 4\\n Log(math.sqrt(-4)) // {\\\"mathjs\\\":\\\"Complex\\\",\\\"re\\\":0,\\\"im\\\":2}\\n}\\n```\", \"title\": \"Built-in Libraries\"}, {\"_src_hash\": \"c9ae46bffb9e02fcec44f247b1e2822078092bae0ba780ed49a3ce4414e3e768\", \"children\": [], \"desc\": \"Text in the strategy interface can be written in both Chinese and English; the web page shows the one matching the current language (refresh the page after switching languages):\\n- Strategy name and descriptions of strategy parameters: write ```Chinese|English```.\\n- Strategy description, usage instructions and other ```Markdown``` text: write ```[trans]Chinese|English[/trans]``` or ```[trans]Chinese||English[/trans]```.\\n- Functions in the strategy code that output strings, such as ```Log()``` and ```LogStatus()```: the same as ```Markdown``` text; texts of status bar buttons are written ```Chinese|English``` directly, without the ```[trans]``` tag.\\n\\n```javascript\\nfunction main() {\\n Log(\\\"[trans]日志|log[/trans]\\\")\\n // no [trans] tag inside buttons\\n var btn = {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\",\\n \\\"description\\\": \\\"描述|description\\\"}\\n var table = {\\n type: \\\"table\\\",\\n title: \\\"[trans]操作|option[/trans]\\\",\\n cols: [\\\"[trans]列1|col1[/trans]\\\", \\\"[trans]列2|col2[/trans]\\\", \\\"[trans]操作|option[/trans]\\\"],\\n rows: [\\n [\\\"[trans]比特币|BTC[/trans]\\\", \\\"[trans]以太坊|ETH[/trans]\\\", btn]\\n ]\\n }\\n LogStatus(\\\"[trans]信息|message[/trans]\\\", \\\"\\\\n`\\\" + JSON.stringify(table) + \\\"`\\\")\\n throw \\\"[trans]错误|error[/trans]\\\"\\n}\\n```\\n\\n```python\\nimport json\\n\\ndef main():\\n Log(\\\"[trans]日志|log[/trans]\\\")\\n btn = {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\",\\n \\\"description\\\": \\\"描述|description\\\"}\\n table = {\\n \\\"type\\\": \\\"table\\\",\\n \\\"title\\\": \\\"[trans]操作|option[/trans]\\\",\\n \\\"cols\\\": [\\\"[trans]列1|col1[/trans]\\\", \\\"[trans]列2|col2[/trans]\\\", \\\"[trans]操作|option[/trans]\\\"],\\n \\\"rows\\\": [\\n [\\\"[trans]比特币|BTC[/trans]\\\", \\\"[trans]以太坊|ETH[/trans]\\\", btn]\\n ]\\n }\\n LogStatus(\\\"[trans]信息|message[/trans]\\\", \\\"\\\\n`\\\" + json.dumps(table) + \\\"`\\\")\\n raise Exception(\\\"[trans]错误|error[/trans]\\\")\\n```\\n\\n```rust\\nfn main() {\\n Log!(\\\"[trans]日志|log[/trans]\\\");\\n let table = r#\\\"{\\n \\\"type\\\": \\\"table\\\",\\n \\\"title\\\": \\\"[trans]操作|option[/trans]\\\",\\n \\\"cols\\\": [\\\"[trans]列1|col1[/trans]\\\", \\\"[trans]列2|col2[/trans]\\\", \\\"[trans]操作|option[/trans]\\\"],\\n \\\"rows\\\": [\\n [\\\"[trans]比特币|BTC[/trans]\\\", \\\"[trans]以太坊|ETH[/trans]\\\",\\n {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\",\\n \\\"description\\\": \\\"描述|description\\\"}]\\n ]\\n }\\\"#;\\n LogStatus!(\\\"[trans]信息|message[/trans]\\\", format!(\\\"\\\\n`{}`\\\", table));\\n Panic!(\\\"[trans]错误|error[/trans]\\\");\\n}\\n```\", \"title\": \"UI Text Localization\"}, {\"_src_hash\": \"e6a2eff22ccb79b68d6412320c2f7508522927ec492fa73fe4dfc0dcceff3dda\", \"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} | 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} | Decodes (parses) a JSON string; a method of the ECMAScript standard built-in object ```JSON```. |\\n| {@fun/Global/JSON.stringify JSON.stringify} | Converts JavaScript values to JSON strings; a method of the ECMAScript standard built-in object ```JSON```. |\\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} | Outputs logs. |\\n| {@fun/Log/LogStatus LogStatus} | Refreshes the status bar of a backtest or live trading page with text, tables, buttons or component objects with a `type` (KPI cards, charts, tabs and more); each call replaces the previous content. |\\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} | Outputs 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} | Gets the Ticker structure (market data) of a spot instrument or contract; without ```symbol``` it uses the currently set trading pair and contract code. |\\n| {@fun/Market/exchange.GetTickers exchange.GetTickers} | Retrieves aggregated market data from the exchange (an array of Ticker structures). |\\n| {@fun/Market/exchange.GetDepth exchange.GetDepth} | Gets the Depth structure, i.e. the order book data, of the spot or contract corresponding to the currently set trading pair and contract code. |\\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. the market's trade (tick) data. |\\n| {@fun/Market/exchange.GetRecords exchange.GetRecords} | Get the Record structure array (i.e. K-line data) of the spot or contract corresponding to the currently set trading pair or contract code. |\\n| {@fun/Market/exchange.GetMarkets exchange.GetMarkets} | Retrieves 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} | Sets the data loaded when the strategy is running. |\\n| {@fun/Market/exchange.GetData exchange.GetData} | Retrieves 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} | Submits a buy order. |\\n| {@fun/Trade/exchange.Sell exchange.Sell} | Submits a sell order. |\\n| {@fun/Trade/exchange.CreateOrder exchange.CreateOrder} | Places an order. |\\n| {@fun/Trade/exchange.ModifyOrder exchange.ModifyOrder} | Modifies the price and quantity of an existing regular order. |\\n| {@fun/Trade/exchange.CancelOrder exchange.CancelOrder} | Cancels an order. |\\n| {@fun/Trade/exchange.GetOrder exchange.GetOrder} | Obtains order information. |\\n| {@fun/Trade/exchange.GetOrders exchange.GetOrders} | Obtains the current unfilled orders. |\\n| {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders} | Retrieves the historical orders of the current trading pair or contract, and supports specifying a particular trading instrument. |\\n| {@fun/Trade/exchange.CreateConditionOrder exchange.CreateConditionOrder} | Creates a conditional order. |\\n| {@fun/Trade/exchange.ModifyConditionOrder exchange.ModifyConditionOrder} | Modifies an existing conditional order, including its order quantity, trigger condition and execution price. |\\n| {@fun/Trade/exchange.CancelConditionOrder exchange.CancelConditionOrder} | Cancels a conditional order. |\\n| {@fun/Trade/exchange.GetConditionOrder exchange.GetConditionOrder} | Retrieves information about a specified conditional order. |\\n| {@fun/Trade/exchange.GetConditionOrders exchange.GetConditionOrders} | Obtains unfinished conditional orders (conditional orders that have not yet been triggered or canceled). |\\n| {@fun/Trade/exchange.GetHistoryConditionOrders exchange.GetHistoryConditionOrders} | Retrieves the historical conditional orders (including triggered, canceled, and expired conditional orders) for the current trading pair or contract, and supports specifying a particular trading instrument. |\\n\\n#### Account\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Account/exchange.GetAccount exchange.GetAccount} | Requests the exchange account information. |\\n| {@fun/Account/exchange.GetAssets exchange.GetAssets} | Requests the asset information of the exchange account. |\\n\\n#### Futures\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Futures/exchange.SetContractType exchange.SetContractType} | Sets the current contract code of the exchange object. |\\n| {@fun/Futures/exchange.GetContractType exchange.GetContractType} | Gets the contract code currently set for the exchange object. |\\n| {@fun/Futures/exchange.SetDirection exchange.SetDirection} | Sets the order direction when calling the exchange.Buy function or exchange.Sell function to place futures contract orders. |\\n| {@fun/Futures/exchange.SetMarginLevel exchange.SetMarginLevel} | Sets the leverage value for the trading pair or contract specified by the ```symbol``` parameter. |\\n| {@fun/Futures/exchange.GetPositions exchange.GetPositions} | Gets position information. |\\n| {@fun/Futures/exchange.GetFundings exchange.GetFundings} | Obtains the funding rate data for the current period. |\\n\\n#### Exchange\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Exchange/exchange.GetName exchange.GetName} | Gets the name of the exchange bound to the current exchange object. |\\n| {@fun/Exchange/exchange.GetLabel exchange.GetLabel} | Obtains the custom label set when configuring the exchange object. |\\n| {@fun/Exchange/exchange.GetCurrency exchange.GetCurrency} | Gets the currently set trading pair. |\\n| {@fun/Exchange/exchange.SetCurrency exchange.SetCurrency} | Switches the current trading pair of the exchange object exchange. |\\n| {@fun/Exchange/exchange.GetQuoteCurrency exchange.GetQuoteCurrency} | Gets the name of the quote currency of the current trading pair, i.e. ```quoteCurrency```. |\\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 default K-line period used when calling the ```exchange.GetRecords()``` function without… |\\n| {@fun/Exchange/exchange.SetMaxBarLen exchange.SetMaxBarLen} | Set the maximum length of the K-line (candlestick chart). |\\n| {@fun/Exchange/exchange.SetPrecision exchange.SetPrecision} | Sets the precision of the price and order amount for the ```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} | Set the current exchange rate of the exchange object. |\\n| {@fun/Exchange/exchange.SetBase exchange.SetBase} | Sets the base URL of the exchange API interface used by the exchange object. |\\n| {@fun/Exchange/exchange.GetBase exchange.GetBase} | Gets the base address of the current exchange API interface. |\\n| {@fun/Exchange/exchange.SetProxy exchange.SetProxy} | Sets the proxy configuration of the exchange object. |\\n| {@fun/Exchange/exchange.SetTimeout exchange.SetTimeout} | Sets the timeout for ```rest``` requests of the exchange object. |\\n| {@fun/Exchange/exchange.Encode exchange.Encode} | Performs signature and encryption computations. |\\n\\n#### IO\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/IO/exchange.IO exchange.IO} | Calls other interfaces related to the exchange object. |\\n| ```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\\\", ...)``` | Switches the current trading pair of the exchange object at runtime. |\\n| ```exchange.IO(\\\"base\\\", ...)``` | Queries or switches the base address of the exchange API. |\\n| ```exchange.IO(mode, value)``` | Switches the trading mode of an exchange, including demo/live trading, cross/isolated margin, hedge/one-way position mode, unified account, margin trading mode and self-trade prevention. |\\n| ```exchange.IO(\\\"rate\\\", ...)``` | Limits how often each API function is called: ```rate``` for smoothed limiting, ```quota``` for quota limiting. |\\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``` and ```tls``` (also written as ```ssl```) protocols as well as the WebSocket ```ws``` and ```wss``` 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} | Executes SQL statements against the live trading database. |\\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. |\\n| {@fun/Threads/ctx.subscribe ctx.subscribe} | Subscribes to WebSocket push streams (market data for a symbol, market-wide tickers, or an account's private streams) and returns a Subscription object. |\\n| {@fun/Threads/ctx.poll ctx.poll} | Takes the next push event from the current thread's subscriptions, with an optional wait timeout. |\\n\\n#### Threads/Subscription\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/Subscription/book Subscription.book} | Reads the order book maintained by this depth subscription itself. |\\n| {@fun/Threads/Subscription/positions Subscription.positions} | Reads the latest positions that a private subscription maintains from pushed updates. |\\n| {@fun/Threads/Subscription/balances Subscription.balances} | Reads the latest balances that a private subscription keeps up to date from pushed events. |\\n| {@fun/Threads/Subscription/unsubscribe Subscription.unsubscribe} | Unsubscribe: releases the reference held by this subscription object; the actual unsubscribe request is sent to the exchange only when the last reference is released. |\\n\\n#### Threads/threading\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/threading/Thread threading.Thread} | Creates concurrent threads. |\\n| {@fun/Threads/threading/getThread threading.getThread} | Gets a thread object based on the specified thread ID. |\\n| {@fun/Threads/threading/mainThread threading.mainThread} | Gets the thread object of the main thread, which is the thread where the ```main()``` function in the strategy is located. |\\n| {@fun/Threads/threading/currentThread threading.currentThread} | Gets the thread object of the current thread. |\\n| {@fun/Threads/threading/Lock threading.Lock} | Creates a thread lock object. |\\n| {@fun/Threads/threading/Condition threading.Condition} | Creates a condition variable object, which is used to implement synchronization and communication between threads in a multi-threaded concurrent environment. |\\n| {@fun/Threads/threading/Event threading.Event} | Creates a *thread event* object, which is used for synchronization between threads, allowing one thread to wait for notification or signal from another thread. |\\n| {@fun/Threads/threading/Dict threading.Dict} | Creates a dictionary object for passing and sharing data between concurrent threads. |\\n| {@fun/Threads/threading/Serve threading.Serve} | Starts an HTTP, TCP or WebSocket (over HTTP) service inside the strategy process and returns a Server object. |\\n| {@fun/Threads/threading/pending threading.pending} | Gets 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 Thread.peekMessage} | Receives messages from a thread. |\\n| {@fun/Threads/Thread/postMessage Thread.postMessage} | Sends messages to a thread. |\\n| {@fun/Threads/Thread/join Thread.join} | Waits for a thread to exit and reclaims its system resources. |\\n| {@fun/Threads/Thread/terminate Thread.terminate} | Forcibly terminates a thread and releases the hardware resources occupied when the thread was created. |\\n| {@fun/Threads/Thread/getData Thread.getData} | Accesses variables recorded in the thread environment. |\\n| {@fun/Threads/Thread/setData Thread.setData} | Stores variables in the thread environment. |\\n| {@fun/Threads/Thread/id Thread.id} | Returns the ```threadId``` of the current multi-threaded object instance. |\\n| {@fun/Threads/Thread/name Thread.name} | Returns the name of the current multi-threaded object instance. |\\n| {@fun/Threads/Thread/eventLoop Thread.eventLoop} | Listens for events received by the current thread (the thread of the caller). |\\n\\n#### Threads/ThreadLock\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/ThreadLock/acquire ThreadLock.acquire} | Requests a thread lock (acquire lock). |\\n| {@fun/Threads/ThreadLock/release ThreadLock.release} | Releases a thread lock (unlock). |\\n\\n#### Threads/ThreadEvent\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/ThreadEvent/set ThreadEvent.set} | Sets an event signal. |\\n| {@fun/Threads/ThreadEvent/clear ThreadEvent.clear} | Clears the signal. |\\n| {@fun/Threads/ThreadEvent/wait ThreadEvent.wait} | Sets event (signal) waiting, which will block until the event (signal) is set; supports setting timeout parameters. |\\n| {@fun/Threads/ThreadEvent/isSet ThreadEvent.isSet} | Determines whether an event (signal) has been set. |\\n\\n#### Threads/ThreadCondition\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/ThreadCondition/notify ThreadCondition.notify} | Wakes up one waiting thread (if any exists). |\\n| {@fun/Threads/ThreadCondition/notifyAll ThreadCondition.notifyAll} | Wakes up all waiting threads. |\\n| {@fun/Threads/ThreadCondition/wait ThreadCondition.wait} | Puts a thread into a waiting state under specific conditions. |\\n| {@fun/Threads/ThreadCondition/acquire ThreadCondition.acquire} | Requests a thread lock (acquire lock). |\\n| {@fun/Threads/ThreadCondition/release ThreadCondition.release} | Releases the thread lock (unlock). |\\n\\n#### Threads/ThreadDict\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/ThreadDict/get ThreadDict.get} | Retrieves the value of a key recorded in a dictionary object. |\\n| {@fun/Threads/ThreadDict/set ThreadDict.set} | Sets key-value pairs. |\\n\\n#### Threads/Server\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/Server/addr Server.addr} | Returns the address and port the service actually listens on. |\\n| {@fun/Threads/Server/close Server.close} | Stops accepting new connections; handlers already running finish normally (graceful shutdown). |\\n| {@fun/Threads/Server/stop Server.stop} | Closes the service (as ```close()```) and then terminates every handler thread that is still running. |\\n| {@fun/Threads/Server/join Server.join} | Waits until the service is closed and no handler is running. |\\n| {@fun/Threads/Server/pending Server.pending} | Returns the number of handlers currently running, i.e. connections or requests being handled. |\\n\\n#### TA\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/TA/TA.MACD TA.MACD} | Calculates the Moving Average Convergence Divergence (MACD) indicator. |\\n| {@fun/TA/TA.KDJ TA.KDJ} | Calculates the Stochastic Oscillator (KDJ). |\\n| {@fun/TA/TA.RSI TA.RSI} | Calculates the Relative Strength Index (RSI). |\\n| {@fun/TA/TA.ATR TA.ATR} | Calculates the Average True Range indicator (ATR). |\\n| {@fun/TA/TA.OBV TA.OBV} | Calculates the On-Balance Volume (OBV). |\\n| {@fun/TA/TA.MA TA.MA} | Calculates the Moving Average indicator (Moving Average). |\\n| {@fun/TA/TA.EMA TA.EMA} | Calculates the Exponential Moving Average (EMA) indicator. |\\n| {@fun/TA/TA.BOLL TA.BOLL} | Calculates the Bollinger Bands indicator. |\\n| {@fun/TA/TA.Alligator TA.Alligator} | Calculates the Alligator indicator. |\\n| {@fun/TA/TA.CMF TA.CMF} | Calculates the Chaikin Money Flow (CMF) indicator. |\\n| {@fun/TA/TA.Highest TA.Highest} | Calculates the highest price within a period. |\\n| {@fun/TA/TA.Lowest TA.Lowest} | Calculates the lowest price over a period. |\\n| {@fun/TA/TA.SMA TA.SMA} | Calculates the Simple Moving Average (SMA) indicator. |\\n\\n#### Talib/OverlapStudies\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/OverlapStudies/talib.ACCBANDS talib.ACCBANDS} | Calculates the Acceleration Bands and returns the upper band, middle band and lower band. |\\n| {@fun/Talib/OverlapStudies/talib.BBANDS talib.BBANDS} | Calculates the Bollinger Bands and returns the upper band, middle band and lower band. |\\n| {@fun/Talib/OverlapStudies/talib.DEMA talib.DEMA} | Calculates the Double Exponential Moving Average. |\\n| {@fun/Talib/OverlapStudies/talib.EMA talib.EMA} | Calculates the Exponential Moving Average. |\\n| {@fun/Talib/OverlapStudies/talib.HT_TRENDLINE talib.HT_TRENDLINE} | Calculates the Hilbert Transform - Instantaneous Trendline. |\\n| {@fun/Talib/OverlapStudies/talib.KAMA talib.KAMA} | Calculates the Kaufman Adaptive Moving Average. |\\n| {@fun/Talib/OverlapStudies/talib.MA talib.MA} | Calculates the Moving Average. |\\n| {@fun/Talib/OverlapStudies/talib.MAMA talib.MAMA} | Calculates the MESA Adaptive Moving Average and returns the MAMA and FAMA. |\\n| {@fun/Talib/OverlapStudies/talib.MAVP talib.MAVP} | Calculates the Moving Average with Variable Period. |\\n| {@fun/Talib/OverlapStudies/talib.MIDPOINT talib.MIDPOINT} | Calculates the MidPoint over Period. |\\n| {@fun/Talib/OverlapStudies/talib.MIDPRICE talib.MIDPRICE} | Calculates the Midpoint Price over Period. |\\n| {@fun/Talib/OverlapStudies/talib.SAR talib.SAR} | Calculates the Parabolic SAR. |\\n| {@fun/Talib/OverlapStudies/talib.SAREXT talib.SAREXT} | Calculates the Parabolic SAR - Extended. |\\n| {@fun/Talib/OverlapStudies/talib.SMA talib.SMA} | Calculates the Simple Moving Average. |\\n| {@fun/Talib/OverlapStudies/talib.T3 talib.T3} | Calculates the Triple Exponential Moving Average (T3). |\\n| {@fun/Talib/OverlapStudies/talib.TEMA talib.TEMA} | Calculates the Triple Exponential Moving Average. |\\n| {@fun/Talib/OverlapStudies/talib.TRIMA talib.TRIMA} | Calculates the Triangular Moving Average. |\\n| {@fun/Talib/OverlapStudies/talib.WMA talib.WMA} | Calculates the Weighted Moving Average. |\\n\\n#### Talib/MomentumIndicators\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/MomentumIndicators/talib.ADX talib.ADX} | Calculates the Average Directional Movement Index. |\\n| {@fun/Talib/MomentumIndicators/talib.ADXR talib.ADXR} | Calculates the Average Directional Movement Index Rating. |\\n| {@fun/Talib/MomentumIndicators/talib.APO talib.APO} | Calculates the Absolute Price Oscillator. |\\n| {@fun/Talib/MomentumIndicators/talib.AROON talib.AROON} | Calculates the Aroon and returns the Aroon Down and Aroon Up. |\\n| {@fun/Talib/MomentumIndicators/talib.AROONOSC talib.AROONOSC} | Calculates the Aroon Oscillator. |\\n| {@fun/Talib/MomentumIndicators/talib.BOP talib.BOP} | Calculates the Balance Of Power. |\\n| {@fun/Talib/MomentumIndicators/talib.CCI talib.CCI} | Calculates the Commodity Channel Index. |\\n| {@fun/Talib/MomentumIndicators/talib.CMO talib.CMO} | Calculates the Chande Momentum Oscillator. |\\n| {@fun/Talib/MomentumIndicators/talib.DX talib.DX} | Calculates the Directional Movement Index. |\\n| {@fun/Talib/MomentumIndicators/talib.IMI talib.IMI} | Calculates the Intraday Momentum Index. |\\n| {@fun/Talib/MomentumIndicators/talib.MACD talib.MACD} | Calculates the Moving Average Convergence/Divergence and returns the MACD line, signal line and histogram. |\\n| {@fun/Talib/MomentumIndicators/talib.MACDEXT talib.MACDEXT} | Calculates the MACD with Controllable MA Type and returns the MACD line, signal line and histogram. |\\n| {@fun/Talib/MomentumIndicators/talib.MACDFIX talib.MACDFIX} | Calculates the Moving Average Convergence/Divergence Fix 12/26 and returns the MACD line, signal line and histogram. |\\n| {@fun/Talib/MomentumIndicators/talib.MFI talib.MFI} | Calculates the Money Flow Index. |\\n| {@fun/Talib/MomentumIndicators/talib.MINUS_DI talib.MINUS_DI} | Calculates the Minus Directional Indicator. |\\n| {@fun/Talib/MomentumIndicators/talib.MINUS_DM talib.MINUS_DM} | Calculates the Minus Directional Movement. |\\n| {@fun/Talib/MomentumIndicators/talib.MOM talib.MOM} | Calculates the Momentum. |\\n| {@fun/Talib/MomentumIndicators/talib.PLUS_DI talib.PLUS_DI} | Calculates the Plus Directional Indicator. |\\n| {@fun/Talib/MomentumIndicators/talib.PLUS_DM talib.PLUS_DM} | Calculates the Plus Directional Movement. |\\n| {@fun/Talib/MomentumIndicators/talib.PPO talib.PPO} | Calculates the Percentage Price Oscillator. |\\n| {@fun/Talib/MomentumIndicators/talib.ROC talib.ROC} | Calculates the Rate of Change, defined as `((price/prevPrice)-1)*100`. |\\n| {@fun/Talib/MomentumIndicators/talib.ROCP talib.ROCP} | Calculates the Rate of Change Percentage, defined as `(price-prevPrice)/prevPrice`. |\\n| {@fun/Talib/MomentumIndicators/talib.ROCR talib.ROCR} | Calculates the Rate of Change Ratio, defined as `price/prevPrice`. |\\n| {@fun/Talib/MomentumIndicators/talib.ROCR100 talib.ROCR100} | Calculates the Rate of Change Ratio 100 Scale, defined as `(price/prevPrice)*100`. |\\n| {@fun/Talib/MomentumIndicators/talib.RSI talib.RSI} | Calculates the Relative Strength Index. |\\n| {@fun/Talib/MomentumIndicators/talib.STOCH talib.STOCH} | Calculates the Stochastic and returns the slow %K and slow %D. |\\n| {@fun/Talib/MomentumIndicators/talib.STOCHF talib.STOCHF} | Calculates the Stochastic Fast and returns the fast %K and fast %D. |\\n| {@fun/Talib/MomentumIndicators/talib.STOCHRSI talib.STOCHRSI} | Calculates the Stochastic Relative Strength Index and returns the fast %K and fast %D. |\\n| {@fun/Talib/MomentumIndicators/talib.TRIX talib.TRIX} | Calculates the 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA. |\\n| {@fun/Talib/MomentumIndicators/talib.ULTOSC talib.ULTOSC} | Calculates the Ultimate Oscillator. |\\n| {@fun/Talib/MomentumIndicators/talib.WILLR talib.WILLR} | Calculates the Williams' %R. |\\n\\n#### Talib/VolumeIndicators\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/VolumeIndicators/talib.AD talib.AD} | Calculates the Chaikin A/D Line. |\\n| {@fun/Talib/VolumeIndicators/talib.ADOSC talib.ADOSC} | Calculates the Chaikin A/D Oscillator. |\\n| {@fun/Talib/VolumeIndicators/talib.OBV talib.OBV} | Calculates the On Balance Volume. |\\n\\n#### Talib/VolatilityIndicators\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/VolatilityIndicators/talib.ATR talib.ATR} | Calculates the Average True Range. |\\n| {@fun/Talib/VolatilityIndicators/talib.NATR talib.NATR} | Calculates the Normalized Average True Range. |\\n| {@fun/Talib/VolatilityIndicators/talib.TRANGE talib.TRANGE} | Calculates the True Range. |\\n\\n#### Talib/CycleIndicators\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/CycleIndicators/talib.HT_DCPERIOD talib.HT_DCPERIOD} | Calculates the Hilbert Transform - Dominant Cycle Period. |\\n| {@fun/Talib/CycleIndicators/talib.HT_DCPHASE talib.HT_DCPHASE} | Calculates the Hilbert Transform - Dominant Cycle Phase. |\\n| {@fun/Talib/CycleIndicators/talib.HT_PHASOR talib.HT_PHASOR} | Calculates the Hilbert Transform - Phasor Components and returns the in-phase component and quadrature component. |\\n| {@fun/Talib/CycleIndicators/talib.HT_SINE talib.HT_SINE} | Calculates the Hilbert Transform - SineWave and returns the sine and lead sine. |\\n| {@fun/Talib/CycleIndicators/talib.HT_TRENDMODE talib.HT_TRENDMODE} | Calculates the Hilbert Transform - Trend vs Cycle Mode. |\\n\\n#### Talib/PriceTransform\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/PriceTransform/talib.AVGDEV talib.AVGDEV} | Calculates the Average Deviation. |\\n| {@fun/Talib/PriceTransform/talib.AVGPRICE talib.AVGPRICE} | Calculates the Average Price. |\\n| {@fun/Talib/PriceTransform/talib.MEDPRICE talib.MEDPRICE} | Calculates the Median Price. |\\n| {@fun/Talib/PriceTransform/talib.TYPPRICE talib.TYPPRICE} | Calculates the Typical Price. |\\n| {@fun/Talib/PriceTransform/talib.WCLPRICE talib.WCLPRICE} | Calculates the Weighted Close Price. |\\n\\n#### Talib/StatisticFunctions\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/StatisticFunctions/talib.BETA talib.BETA} | Calculates the Beta. |\\n| {@fun/Talib/StatisticFunctions/talib.CORREL talib.CORREL} | Calculates the Pearson's Correlation Coefficient (r). |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG talib.LINEARREG} | Calculates the Linear Regression. |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG_ANGLE talib.LINEARREG_ANGLE} | Calculates the Linear Regression Angle. |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG_INTERCEPT talib.LINEARREG_INTERCEPT} | Calculates the Linear Regression Intercept. |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG_SLOPE talib.LINEARREG_SLOPE} | Calculates the Linear Regression Slope. |\\n| {@fun/Talib/StatisticFunctions/talib.STDDEV talib.STDDEV} | Calculates the Standard Deviation. |\\n| {@fun/Talib/StatisticFunctions/talib.TSF talib.TSF} | Calculates the Time Series Forecast. |\\n| {@fun/Talib/StatisticFunctions/talib.VAR talib.VAR} | Calculates the Variance. |\\n\\n#### Talib/MathTransform\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/MathTransform/talib.ACOS talib.ACOS} | Calculates the arc cosine of each element (Vector Trigonometric ACos). |\\n| {@fun/Talib/MathTransform/talib.ASIN talib.ASIN} | Calculates the arc sine of each element (Vector Trigonometric ASin). |\\n| {@fun/Talib/MathTransform/talib.ATAN talib.ATAN} | Calculates the arc tangent of each element (Vector Trigonometric ATan). |\\n| {@fun/Talib/MathTransform/talib.CEIL talib.CEIL} | Rounds each element up to an integer (Vector Ceil). |\\n| {@fun/Talib/MathTransform/talib.COS talib.COS} | Calculates the cosine of each element (Vector Trigonometric Cos). |\\n| {@fun/Talib/MathTransform/talib.COSH talib.COSH} | Calculates the hyperbolic cosine of each element (Vector Trigonometric Cosh). |\\n| {@fun/Talib/MathTransform/talib.EXP talib.EXP} | Calculates the exponential (e to the power of x) of each element (Vector Arithmetic Exp). |\\n| {@fun/Talib/MathTransform/talib.FLOOR talib.FLOOR} | Rounds each element down to an integer (Vector Floor). |\\n| {@fun/Talib/MathTransform/talib.LN talib.LN} | Calculates the natural logarithm of each element (Vector Log Natural). |\\n| {@fun/Talib/MathTransform/talib.LOG10 talib.LOG10} | Calculates the base-10 logarithm of each element (Vector Log10). |\\n| {@fun/Talib/MathTransform/talib.SIN talib.SIN} | Calculates the sine of each element (Vector Trigonometric Sin). |\\n| {@fun/Talib/MathTransform/talib.SINH talib.SINH} | Calculates the hyperbolic sine of each element (Vector Trigonometric Sinh). |\\n| {@fun/Talib/MathTransform/talib.SQRT talib.SQRT} | Calculates the square root of each element (Vector Square Root). |\\n| {@fun/Talib/MathTransform/talib.TAN talib.TAN} | Calculates the tangent of each element (Vector Trigonometric Tan). |\\n| {@fun/Talib/MathTransform/talib.TANH talib.TANH} | Calculates the hyperbolic tangent of each element (Vector Trigonometric Tanh). |\\n\\n#### Talib/MathOperators\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/MathOperators/talib.ADD talib.ADD} | Adds two arrays element by element (Vector Arithmetic Add). |\\n| {@fun/Talib/MathOperators/talib.DIV talib.DIV} | Divides the first array by the second, element by element (Vector Arithmetic Div). |\\n| {@fun/Talib/MathOperators/talib.MAX talib.MAX} | Calculates the Highest Value over a Specified Period. |\\n| {@fun/Talib/MathOperators/talib.MAXINDEX talib.MAXINDEX} | Calculates the Index of Highest Value over a Specified Period. |\\n| {@fun/Talib/MathOperators/talib.MIN talib.MIN} | Calculates the Lowest Value over a Specified Period. |\\n| {@fun/Talib/MathOperators/talib.MININDEX talib.MININDEX} | Calculates the Index of Lowest Value over a Specified Period. |\\n| {@fun/Talib/MathOperators/talib.MINMAX talib.MINMAX} | Calculates the Lowest and Highest Values over a Specified Period and returns the minimum and maximum. |\\n| {@fun/Talib/MathOperators/talib.MINMAXINDEX talib.MINMAXINDEX} | Calculates the Indexes of Lowest and Highest Values over a Specified Period and returns the minimum index and maximum index. |\\n| {@fun/Talib/MathOperators/talib.MULT talib.MULT} | Multiplies two arrays element by element (Vector Arithmetic Mult). |\\n| {@fun/Talib/MathOperators/talib.SUB talib.SUB} | Subtracts the second array from the first, element by element (Vector Arithmetic Subtraction). |\\n| {@fun/Talib/MathOperators/talib.SUM talib.SUM} | Calculates the Summation. |\\n\\n#### Talib/PatternRecognition\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/PatternRecognition/talib.CDL2CROWS talib.CDL2CROWS} | Detects the Two Crows candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDL3BLACKCROWS talib.CDL3BLACKCROWS} | Detects the Three Black Crows candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDL3INSIDE talib.CDL3INSIDE} | Detects the Three Inside Up/Down candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDL3LINESTRIKE talib.CDL3LINESTRIKE} | Detects the Three-Line Strike candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDL3OUTSIDE talib.CDL3OUTSIDE} | Detects the Three Outside Up/Down candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDL3STARSINSOUTH talib.CDL3STARSINSOUTH} | Detects the Three Stars In The South candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDL3WHITESOLDIERS talib.CDL3WHITESOLDIERS} | Detects the Three Advancing White Soldiers candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLABANDONEDBABY talib.CDLABANDONEDBABY} | Detects the Abandoned Baby candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLADVANCEBLOCK talib.CDLADVANCEBLOCK} | Detects the Advance Block candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLBELTHOLD talib.CDLBELTHOLD} | Detects the Belt-hold candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLBREAKAWAY talib.CDLBREAKAWAY} | Detects the Breakaway candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLCLOSINGMARUBOZU talib.CDLCLOSINGMARUBOZU} | Detects the Closing Marubozu candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLCONCEALBABYSWALL talib.CDLCONCEALBABYSWALL} | Detects the Concealing Baby Swallow candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLCOUNTERATTACK talib.CDLCOUNTERATTACK} | Detects the Counterattack candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLDARKCLOUDCOVER talib.CDLDARKCLOUDCOVER} | Detects the Dark Cloud Cover candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLDOJI talib.CDLDOJI} | Detects the Doji candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLDOJISTAR talib.CDLDOJISTAR} | Detects the Doji Star candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLDRAGONFLYDOJI talib.CDLDRAGONFLYDOJI} | Detects the Dragonfly Doji candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLENGULFING talib.CDLENGULFING} | Detects the Engulfing Pattern candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLEVENINGDOJISTAR talib.CDLEVENINGDOJISTAR} | Detects the Evening Doji Star candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLEVENINGSTAR talib.CDLEVENINGSTAR} | Detects the Evening Star candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLGAPSIDESIDEWHITE talib.CDLGAPSIDESIDEWHITE} | Detects the Up/Down-gap side-by-side white lines candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLGRAVESTONEDOJI talib.CDLGRAVESTONEDOJI} | Detects the Gravestone Doji candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHAMMER talib.CDLHAMMER} | Detects the Hammer candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHANGINGMAN talib.CDLHANGINGMAN} | Detects the Hanging Man candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHARAMI talib.CDLHARAMI} | Detects the Harami Pattern candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHARAMICROSS talib.CDLHARAMICROSS} | Detects the Harami Cross Pattern candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHIGHWAVE talib.CDLHIGHWAVE} | Detects the High-Wave Candle candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHIKKAKE talib.CDLHIKKAKE} | Detects the Hikkake Pattern candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHIKKAKEMOD talib.CDLHIKKAKEMOD} | Detects the Modified Hikkake Pattern candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHOMINGPIGEON talib.CDLHOMINGPIGEON} | Detects the Homing Pigeon candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLIDENTICAL3CROWS talib.CDLIDENTICAL3CROWS} | Detects the Identical Three Crows candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLINNECK talib.CDLINNECK} | Detects the In-Neck Pattern candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLINVERTEDHAMMER talib.CDLINVERTEDHAMMER} | Detects the Inverted Hammer candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLKICKING talib.CDLKICKING} | Detects the Kicking candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLKICKINGBYLENGTH talib.CDLKICKINGBYLENGTH} | Detects the Kicking - bull/bear determined by the longer marubozu candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLLADDERBOTTOM talib.CDLLADDERBOTTOM} | Detects the Ladder Bottom candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLLONGLEGGEDDOJI talib.CDLLONGLEGGEDDOJI} | Detects the Long Legged Doji candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLLONGLINE talib.CDLLONGLINE} | Detects the Long Line Candle candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLMARUBOZU talib.CDLMARUBOZU} | Detects the Marubozu candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLMATCHINGLOW talib.CDLMATCHINGLOW} | Detects the Matching Low candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLMATHOLD talib.CDLMATHOLD} | Detects the Mat Hold candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLMORNINGDOJISTAR talib.CDLMORNINGDOJISTAR} | Detects the Morning Doji Star candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLMORNINGSTAR talib.CDLMORNINGSTAR} | Detects the Morning Star candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLONNECK talib.CDLONNECK} | Detects the On-Neck Pattern candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLPIERCING talib.CDLPIERCING} | Detects the Piercing Pattern candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLRICKSHAWMAN talib.CDLRICKSHAWMAN} | Detects the Rickshaw Man candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLRISEFALL3METHODS talib.CDLRISEFALL3METHODS} | Detects the Rising/Falling Three Methods candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLSEPARATINGLINES talib.CDLSEPARATINGLINES} | Detects the Separating Lines candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLSHOOTINGSTAR talib.CDLSHOOTINGSTAR} | Detects the Shooting Star candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLSHORTLINE talib.CDLSHORTLINE} | Detects the Short Line Candle candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLSPINNINGTOP talib.CDLSPINNINGTOP} | Detects the Spinning Top candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLSTALLEDPATTERN talib.CDLSTALLEDPATTERN} | Detects the Stalled Pattern candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLSTICKSANDWICH talib.CDLSTICKSANDWICH} | Detects the Stick Sandwich candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLTAKURI talib.CDLTAKURI} | Detects the Takuri (Dragonfly Doji with very long lower shadow) candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLTASUKIGAP talib.CDLTASUKIGAP} | Detects the Tasuki Gap candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLTHRUSTING talib.CDLTHRUSTING} | Detects the Thrusting Pattern candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLTRISTAR talib.CDLTRISTAR} | Detects the Tristar Pattern candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLUNIQUE3RIVER talib.CDLUNIQUE3RIVER} | Detects the Unique 3 River candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLUPSIDEGAP2CROWS talib.CDLUPSIDEGAP2CROWS} | Detects the Upside Gap Two Crows candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLXSIDEGAP3METHODS talib.CDLXSIDEGAP3METHODS} | Detects the Upside/Downside Gap Three Methods candlestick pattern. |\\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 os.open} | Open a file in the specified mode. |\\n| {@fun/OS/os/fgets os.fgets} | Read the entire file content at once. |\\n| {@fun/OS/os/fputs os.fputs} | Write content to a file. |\\n| {@fun/OS/os/mmap os.mmap} | Reads the whole file and returns its binary data as an ArrayBuffer. |\\n| {@fun/OS/os/getRootDir os.getRootDir} | Get the root directory path for file operations. |\\n| {@fun/OS/os/listFiles os.listFiles} | List files and subdirectories in the specified directory. |\\n| {@fun/OS/os/exists os.exists} | Check if the specified file or directory exists. |\\n| {@fun/OS/os/remove os.remove} | Delete the specified file or empty directory. |\\n| {@fun/OS/os/mkdir os.mkdir} | Create a directory. |\\n| {@fun/OS/os/rmdir os.rmdir} | Remove a directory and all its contents. |\\n| {@fun/OS/os/rename os.rename} | Rename a file or move a file. |\\n| {@fun/OS/os/stat os.stat} | Get detailed statistics information of a file. |\\n| {@fun/OS/os/exit os.exit} | Exit the program. |\\n\\n#### OS/File\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/OS/File/close File.close} | Close the file and release associated resources. |\\n| {@fun/OS/File/puts File.puts} | Write one or more strings to a file. |\\n| {@fun/OS/File/printf File.printf} | Write formatted data to file. |\\n| {@fun/OS/File/flush File.flush} | Flush the file buffer to ensure data is written to disk. |\\n| {@fun/OS/File/tell File.tell} | Get the current file pointer position. |\\n| {@fun/OS/File/seek File.seek} | Move the file pointer to a specified position. |\\n| {@fun/OS/File/eof File.eof} | Check if the file pointer has reached the end of file. |\\n| {@fun/OS/File/read File.read} | Read data from a file. |\\n| {@fun/OS/File/write File.write} | Write string data to a file. |\\n| {@fun/OS/File/getline File.getline} | Read the next line from the file. |\\n| {@fun/OS/File/toString File.toString} | Get the string representation of the file object. |\\n\\n### Structures\\n\\n| Name | Description |\\n| - | - |\\n| {@struct/Ticker Ticker} | Market data returned by ```exchange.GetTicker()```: high, low, best ask, best bid, last price, open, volume and open interest. |\\n| {@struct/Depth Depth} | Market depth returned by ```exchange.GetDepth()```: the asks ```Asks``` and bids ```Bids``` (OrderBook arrays) and a timestamp. |\\n| {@struct/OrderBook OrderBook} | One price level of the asks or bids in market depth (Depth): price and amount. |\\n| {@struct/Trade Trade} | Market trade records returned by ```exchange.GetTrades()```, including the trade Id, time, price, amount and side. |\\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} | Returned by ```exchange.GetMarkets()```: an instrument's base and quote assets, price and amount steps and precisions, order quantity and notional limits, and contract value. |\\n| {@struct/Order Order} | Returned by ```exchange.GetOrder()```, ```exchange.GetOrders()``` and similar: order ID, price, amount, filled amount, average price, status, type, offset, contract code and conditional order settings. |\\n| {@struct/Condition Condition} | Conditional order settings: the conditional order type and the take-profit and stop-loss trigger and order prices, used to set the trigger conditions and execution prices of conditional orders. |\\n| {@struct/Account Account} | Returned by ```exchange.GetAccount()```: the available and frozen amounts of the quote and base currencies, plus equity and unrealized profit and loss on futures. |\\n| {@struct/Asset Asset} | One item of the array returned by ```exchange.GetAssets()```: the available and frozen amounts of one currency. |\\n| {@struct/Position Position} | Returned by ```exchange.GetPositions()```: instrument, leverage, amount and frozen amount, average price, unrealized profit, direction, contract code and margin. |\\n| {@struct/Funding Funding} | Returned by ```exchange.GetFundings()```: instrument, settlement interval, time and funding rate; only cryptocurrency perpetual contracts have funding rates. |\\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``` parameter structure while calling the HttpQuery function. |\\n| {@struct/OtherStruct/LogStatus-table LogStatus-table} | Status bar table output with LogStatus: columns can set number formats, up/down colors and units; cells can be merged or hold buttons; several tables can be shown as tabs. |\\n| {@struct/OtherStruct/LogStatus-btnTypeOne LogStatus-btnTypeOne} | Older form of the status bar button structure (input controls without ```settings```), still supported. |\\n| {@struct/OtherStruct/LogStatus-btnTypeTwo LogStatus-btnTypeTwo} | JSON structure of a status bar button (current form, with ```settings``` on input controls). |\\n| {@struct/OtherStruct/Chart-options Chart-options} | This JSON is used to configure chart settings for the custom plotting function ```Chart()```. |\\n| {@struct/OtherStruct/Chart-return Chart-return} | The chart object returned by Chart, used to write data, update the configuration and clear the 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/KLineChart-return KLineChart-return} | The chart object returned by KLineChart, which draws on K-lines in a ```Pine```-like way. |\\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/exchange.Go-return exchange.Go-return} | The concurrent object returned by exchange.Go; its ```wait()``` method returns the result of the concurrent call. |\\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 ```exec()``` method of objects created by the ```Dial()``` function. |\\n| {@struct/OtherStruct/Dial-return Dial-return} | The connection object returned by Dial. |\\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 threads in ```JavaScript``` language strategies. |\\n\\n#### OtherStruct/LogStatus-display\\n\\n| Name | Description |\\n| - | - |\\n| {@struct/OtherStruct/LogStatus-display/grid grid} | Arranges components in columns and drops columns automatically when the container gets narrow. |\\n| {@struct/OtherStruct/LogStatus-display/tabs tabs} | Groups components into tabs; the selected tab is kept when the status bar refreshes. |\\n| {@struct/OtherStruct/LogStatus-display/kpi kpi} | Shows one prominent number with optional unit, change and hint, for equity, returns or the last price. |\\n| {@struct/OtherStruct/LogStatus-display/stat stat} | Lists label and value pairs, for details such as balances, frozen funds, leverage or liquidation price. |\\n| {@struct/OtherStruct/LogStatus-display/progress progress} | Shows a ratio, or current value / total, as a bar. |\\n| {@struct/OtherStruct/LogStatus-display/gauge gauge} | Shows where a value sits in a range on a half-circle dial, with optional threshold colors; for RSI, exposure or risk. |\\n| {@struct/OtherStruct/LogStatus-display/sparkline sparkline} | Shows a number with a small trend line, colored by the first-to-last change by default. |\\n| {@struct/OtherStruct/LogStatus-display/chart chart} | Draws line, bar or area charts with several series, a right axis and buy/sell marks; use Chart for more options. |\\n| {@struct/OtherStruct/LogStatus-display/heatmap heatmap} | Shades a 2D grid by value, for returns by period and symbol or correlation matrices. |\\n| {@struct/OtherStruct/LogStatus-display/calendar calendar} | Shows returns as daily heat cells (like a contribution graph) or as a year × month table. |\\n| {@struct/OtherStruct/LogStatus-display/histogram histogram} | Bins raw data automatically and shows the counts with sample size, mean, median and share of positive values. |\\n| {@struct/OtherStruct/LogStatus-display/pie pie} | Shows the share of each part in the total; a donut by default with the total in the center. |\\n| {@struct/OtherStruct/LogStatus-display/timeline timeline} | Lists events in order, for fills, trading signals or risk events. |\\n| {@struct/OtherStruct/LogStatus-display/markdown markdown} | Renders Markdown text with headings, lists, bold and tables, for strategy notes and market commentary. |\\n| {@struct/OtherStruct/LogStatus-display/alert alert} | Shows an info, success, warning or error message with an icon, for risk and error notices. |\\n| {@struct/OtherStruct/LogStatus-display/badge badge} | Shows small labels with a dot inline, so they can follow a line of text. |\\n\\n### Built-in Variables and Constants\\n\\n#### EXCHANGE\\n\\n| Name | Description |\\n| - | - |\\n| {@var/EXCHANGE/exchange exchange} | The first exchange object added in the strategy live trading settings and backtesting settings. |\\n| {@var/EXCHANGE/exchanges exchanges} | An array of exchange objects that contains all the exchange objects added in the strategy's live trading settings or backtesting settings, where exchanges[0] is exchange. |\\n\\n#### ORDER_STATE\\n\\n| Name | Description |\\n| - | - |\\n| {@var/ORDER_STATE/ORDER_STATE_PENDING ORDER_STATE_PENDING} | The order is pending (open, possibly partially filled); the value is ```0```. |\\n| {@var/ORDER_STATE/ORDER_STATE_CLOSED ORDER_STATE_CLOSED} | The order is completed (fully filled); the value is ```1```. |\\n| {@var/ORDER_STATE/ORDER_STATE_CANCELED ORDER_STATE_CANCELED} | The order is canceled; the value is ```2```. |\\n| {@var/ORDER_STATE/ORDER_STATE_UNKNOWN ORDER_STATE_UNKNOWN} | The order status is unknown (any other status); the value is ```3```. |\\n\\n#### ORDER_TYPE\\n\\n| Name | Description |\\n| - | - |\\n| {@var/ORDER_TYPE/ORDER_TYPE_BUY ORDER_TYPE_BUY} | A buy order; the value is ```0```. |\\n| {@var/ORDER_TYPE/ORDER_TYPE_SELL ORDER_TYPE_SELL} | A sell order; the value is ```1```. |\\n| {@var/ORDER_TYPE/ORDER_TYPE_NONE ORDER_TYPE_NONE} | No direction; the value is ```2```. |\\n\\n#### ORDER_CONDITION_TYPE\\n\\n| Name | Description |\\n| - | - |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_OCO ORDER_CONDITION_TYPE_OCO} | An OCO order (One-Cancels-the-Other): take-profit and stop-loss conditions are set together, and when one triggers the other is canceled automatically; the value is ```0```. |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_TP ORDER_CONDITION_TYPE_TP} | A take-profit order: an order is placed when the price reaches the take-profit trigger price; the value is ```1```. |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_SL ORDER_CONDITION_TYPE_SL} | A stop-loss order: an order is placed when the price reaches the stop-loss trigger price, to limit losses; the value is ```2```. |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_GENERIC ORDER_CONDITION_TYPE_GENERIC} | A generic conditional order: its behavior depends on the exchange, and it only appears in query results; the value is ```3```. |\\n\\n#### POSITION_DIRECTION\\n\\n| Name | Description |\\n| - | - |\\n| {@var/POSITION_DIRECTION/PD_LONG PD_LONG} | A long position; the value is ```0```. |\\n| {@var/POSITION_DIRECTION/PD_SHORT PD_SHORT} | A short position; the value is ```1```. |\\n\\n#### ORDER_OFFSET\\n\\n| Name | Description |\\n| - | - |\\n| {@var/ORDER_OFFSET/ORDER_OFFSET_OPEN ORDER_OFFSET_OPEN} | An opening order; the value is ```0```. |\\n| {@var/ORDER_OFFSET/ORDER_OFFSET_CLOSE ORDER_OFFSET_CLOSE} | A closing order; the value is ```1```. |\\n\\n#### PERIOD\\n\\n| Name | Description |\\n| - | - |\\n| {@var/PERIOD/PERIOD_M1 PERIOD_M1} | 1-minute K-line period; the value is ```60```. |\\n| {@var/PERIOD/PERIOD_M3 PERIOD_M3} | 3-minute K-line period; the value is ```180```. |\\n| {@var/PERIOD/PERIOD_M5 PERIOD_M5} | 5-minute K-line period; the value is ```300```. |\\n| {@var/PERIOD/PERIOD_M15 PERIOD_M15} | 15-minute K-line period; the value is ```900```. |\\n| {@var/PERIOD/PERIOD_M30 PERIOD_M30} | 30-minute K-line period; the value is ```1800```. |\\n| {@var/PERIOD/PERIOD_H1 PERIOD_H1} | 1-hour K-line period; the value is ```3600```. |\\n| {@var/PERIOD/PERIOD_H2 PERIOD_H2} | 2-hour K-line period; the value is ```7200```. |\\n| {@var/PERIOD/PERIOD_H4 PERIOD_H4} | 4-hour K-line period; the value is ```14400```. |\\n| {@var/PERIOD/PERIOD_H6 PERIOD_H6} | 6-hour K-line period; the value is ```21600```. |\\n| {@var/PERIOD/PERIOD_H12 PERIOD_H12} | 12-hour K-line period; the value is ```43200```. |\\n| {@var/PERIOD/PERIOD_D1 PERIOD_D1} | 1-day K-line period; the value is ```86400```. |\\n| {@var/PERIOD/PERIOD_D3 PERIOD_D3} | 3-day K-line period; the value is ```259200```. |\\n| {@var/PERIOD/PERIOD_W1 PERIOD_W1} | 1-week K-line period; the value is ```604800```. |\\n\\n#### LOG_TYPE\\n\\n| Name | Description |\\n| - | - |\\n| {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY} | A buy order log; the value is ```0```. |\\n| {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL} | A sell order log; the value is ```1```. |\\n| {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL} | An order cancellation log; the value is ```2```. |\\n\\n### Conventions\\n\\n| Name | Description |\\n| - | - |\\n| {@conventions/symbol Symbols} | Functions of exchange objects specify an instrument with the string parameter ```symbol```. |\\n| {@conventions/errors Failures and null values} | ### Failed calls return a null value |\\n\\n### Exchanges\\n\\n| Name | Description |\\n| - | - |\\n| {@exchanges/capabilities Capability Matrix} | Support of the standard functions and trading-mode commands per exchange object. |\"], \"title\": \"API Quick Reference\"}], \"desc\": \"Covers strategy structure (lifecycle, main loop, event-driven), notes for each programming language, strategy parameters, interactive controls, template libraries, built-in libraries, Chinese/English text in the strategy UI, and a categorized quick reference of all API functions.\", \"title\": \"Writing Strategies\"}, {\"_src_hash\": \"b2ef397d9c19797aa172580dbb1d94a9a3ec5a227c299fb6257d63ef557b2804\", \"children\": [{\"_src_hash\": \"1f109b30b0c9c7c618fdb5acae43920f63139b18b61d401375a11da54ba524e8\", \"children\": [{\"_src_hash\": \"7ea9e6c890f95ac5f1d5a5d4ee421688952ef8fdb5954535b10b043b53fc45cd\", \"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 {@extended-api-interface/ai-integration AI Integration}).\", \"title\": \"AI Assistant\"}, {\"_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 {@writing-strategies/template-library template library} references (see {@writing-strategies/strategy-parameters Strategy Parameters}, {@writing-strategies/interactive-controls 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\": \"b7fa9843397c2186a44dc4f7aa1eabd03bdc719f7628efdf82a55e4cf5f57901\", \"desc\": \"A history version is a snapshot of the strategy at a point in time; use it to roll back or compare code, or to have a live robot run a specific version. On the **Strategy Editing Page**, click the \\\"History Version\\\" button in the \\\"Code\\\" editing area to open the history version management page.\\n\\n### Creating and managing snapshots\\n- Create: if the strategy has no snapshot yet, click \\\"Create Now\\\"; otherwise click \\\"Create History Version\\\" above the snapshot list on the right. A snapshot includes the strategy code, notes, description, manual, parameter design, interaction design and so on.\\n- Manage: rename a snapshot, delete it, or restore the strategy to a snapshot's version.\\n- Preview: click \\\"Preview\\\" at the bottom left of the page to view the code, notes, description, manual, parameter design and interaction design in the selected snapshot.\\n- Compare: click \\\"Compare\\\" at the bottom left of the page to see the differences between the selected snapshot and the current strategy.\\n\\n### Running a history version live\\n- **Set the default running version**: select a version on the history version management page, click \\\"Modify\\\" in the menu and check \\\"Set as Default Version\\\" in the dialog. Without it, the latest version runs by default.\\n- **Use a history version in a live robot**: when creating a robot or changing its parameters, the strategy owner can choose a history version of the strategy to run; this works only for the strategy owner.\\n- **Versions of rented strategies**: a renter can run only the default running version set by the strategy owner and cannot choose other history versions; the owner controls the version used by 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 Remote Editing}).\\n- {@backtesting-system/backtest-configuration-and-saving Backtest configuration and saving}: save the backtest configuration and strategy parameters with the strategy (see Backtesting System).\\n- {@platform-basics/strategy-library/import-and-export-of-complete-strategies Import and export of complete strategies}: export and import a strategy with its parameters and everything else (see Platform Basics → Strategy Library).\\n\\n### Editor shortcuts\\n\\n- **Command Palette**: right-click in the code editing area and choose \\\"Command Palette\\\" to see the keyboard shortcuts and editor commands for each feature.\\n\\n ![Command Palette display in strategy editor menu](/upload/asset/2e429269f02185dfbab3b.png)\\n\\n- **Go to definition and references**: select the content to look up and right-click:\\n - Go to Definition: jump to where it is defined.\\n - Go to References: jump to where it is referenced.\\n - Peek - Peek Definition: view the definition of the selected code without leaving the current line.\\n - Peek - Peek References: view references to it from other lines without leaving the current line, with quick navigation.\\n\\n- **Syntax manual lookup**: in the \\\"Code\\\" editing area, hold down ```⌘``` (Mac) or ```Ctrl``` (Windows) and hover over a **variable name** or **function name**; a link appears, and clicking it opens the \\\"Syntax Manual\\\" at that entry.\\n\\n ![Syntax Manual Quick Reference in Strategy Editor](/upload/asset/2e4d0722af99164f69996.png)\", \"title\": \"Strategy Editor\"}, {\"_src_hash\": \"52a0467fffa7a132a36928f7cec7f22e6cde2328cb5b0c7c7f7ca8b7f6dd4fbf\", \"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 5 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\": \"bf9d51bd08019586148eabbbfd5e4e6d10b626152cb43b04d405cbaedeeac9e0\", \"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```.\\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- If the strategy has not been modified at all for more than 30 days (neither saved on the website nor synced remotely), sync is refused (return code 405); save the strategy once on the website or click \\\"Update Token\\\" to restore it.\\n- When uploading with ```curl```, the source code must not exceed 8 MB.\\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 (with the AI assistant and history versions), the debugging tool, and remote editing from a local editor.\", \"title\": \"Development Tools\"}, {\"_src_hash\": \"fab552dd29add20dfa0800bedfa98a368ddbe0b418a6980a4c51004f162185f8\", \"children\": [{\"_src_hash\": \"570b8e082f044205154a07ddad0adcd3a500dfc4cee651189ea41f5ec9e8334a\", \"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 Backtest Page Shortcuts}). The configuration can be saved into the strategy source, see {@backtesting-system/backtest-configuration-and-saving Backtest Configuration and Saving}.\\n- AI assistant: start a backtest with the MCP tool ```run_backtest``` and read the result with ```get_backtest```, see {@extended-api-interface/ai-integration 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 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. |\\n| Mode | Simulated tick or real tick, see {@backtesting-system/backtest-modes-and-order-matching Backtest Modes and Order Matching}. |\\n| Exchange, trading pair | Each exchange object has its own simulated account; pairs are written like ```BTC_USDT```. |\\n| Initial funds | Initial balances of the quote currency (e.g. USDT) and the base currency (e.g. BTC). |\\n| Fees | Maker and taker rates in percent. |\\n| Slippage | Number of price ticks (minimum price increments) added outside the simulated best bid and ask; default 0. |\\n| Network delay | Milliseconds the virtual clock advances on every exchange call; default 200. |\\n| Depth levels, amount per level | Number of levels ```GetDepth()``` returns (1-20) and the amount on each simulated level. |\\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, or a {@backtesting-system/custom-data-source Custom Data Source}. |\\n\\nFurther details:\\n- The smaller the base K-line period, the closer the generated ticks are to the real market and the slower the backtest; strategy K-lines are built from base K-lines, so the K-line period cannot be shorter than the base period.\\n- On cryptocurrency futures exchanges the contract defaults to ```swap``` (perpetual); to use another contract, call ```exchange.SetContractType()``` in the strategy first.\\n- Coin-margined contracts use the base currency as margin, so set the base-currency balance.\\n- Fees default to 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 applies only in simulated-tick mode; real-tick mode uses the replayed real order book, and there the depth levels are the real depth requested from the 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; ```JavaScript``` and ```Python``` strategies do not call ```onexit()``` in that case (see {@writing-strategies/strategy-structure/onexit onexit()} for how to handle this), while ```Rust``` strategies call ```onexit()``` automatically.\\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\": \"e2749e2279484d796b47a8d01c8fb81017b8728f964b1e8164757226846dc496\", \"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 outward from the best bid and ask; adjacent levels are spaced by the bid-ask spread (2 ticks + 2 × slippage), 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. The platform's data service caps each data request per symbol (50 MB, plus a limit of 530,000 records); both modes are subject to it (custom data sources are not), but real-tick data is large and slow to backtest, so it is affected most and the time range is limited; 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. In real-tick mode keep the ```Sleep()``` in the strategy loop short (e.g. 100 ms).\\n\\n### How market moments advance\\n\\nIn both modes, at 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.\\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- Opening a futures position freezes margin of notional value ÷ leverage plus the estimated fee; 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```javascript\\n/*backtest\\nstart: 2025-04-01 08:00:00\\nend: 2025-04-18 00:00:00\\nperiod: 1m\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"balance\\\":1000000}]\\nmode: 1\\n*/\\n\\nvar delta = 50\\nvar lotSize = 0.001\\nvar lastPrice = null\\nvar direction = null\\n\\nfunction main() {\\n while (true) {\\n var ticker = _C(exchange.GetTicker)\\n if (!lastPrice) {\\n lastPrice = ticker.Last\\n }\\n var diff = ticker.Last - lastPrice\\n if ((!direction || direction == \\\"long\\\") && diff >= delta) {\\n // 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\": \"b38fa0c7ee25c74b7120be3f9885678a89a08db21d8cee12e472f2213db83af2\", \"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```javascript\\n/*backtest\\nstart: 2024-01-01 00:00:00\\nend: 2024-03-01 00:00:00\\nperiod: 1h\\nbasePeriod: 15m\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"balance\\\":10000,\\\"stocks\\\":0,\\\"fee\\\":[0.1,0.1]}]\\nargs: [[\\\"fast\\\",5],[\\\"slow\\\",20]]\\n*/\\n```\\n\\nComment syntax per language: JavaScript, 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], ...]```; ```[\\\"name\\\", value, templateId]``` sets a template's parameter. |\\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 Custom Data Source}. |\\n\\nThe other options of the backtest form (slippage, network delay, failure probability, max K-line bars, etc.) are not written into the comment block; they are stored with the strategy record when you \\\"Save Strategy\\\". The local backtest engines also read this block, but only some of its keys, see {@backtesting-system/local-backtesting-engine Local Backtesting Engine}.\", \"title\": \"Backtest Configuration and Saving\"}, {\"_src_hash\": \"dd6470282516587ab608bcc65984e23b1370d637156c2044460a87a54b6bb09d\", \"desc\": \"Which programming languages and exchanges the backtest system supports, and where strategies in each language are backtested.\\n\\n### Programming languages\\n\\nThe backtesting system supports strategies written in JavaScript, Python, Rust, [PINE](https://www.fmz.com/bbs-topic/9315), [MyLanguage](https://www.fmz.com/bbs-topic/2569) and Workflow.\\n\\n- JavaScript strategies 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; third-party crates declared in the strategy's frontmatter are fetched at compile time, so no local toolchain is needed. The backtest node defaults to \\\"Cloud\\\" (runs on the platform's servers); you can also choose \\\"Local\\\", which runs in the browser.\\n- For Python strategies the backtest node defaults to \\\"Cloud\\\" (the platform's public servers); you can also choose your own docker, or \\\"Local: Python3\\\" to backtest in the browser (run with Pyodide). A backtest on a docker, like live trading, uses 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\\n These are the exchange IDs used for backtesting (the ```eid``` in the ```/*backtest*/``` configuration and in the MCP tool ```run_backtest```, matching the names of the history data server). For most exchanges they equal what ```exchange.GetName()``` returns in live trading, but a few differ: backtest ```OKX``` and ```Futures_OKX``` correspond to live ```OKEX``` and ```Futures_OKCoin``` (OKX futures); backtest ```HTX``` and ```Futures_HTX``` correspond to live ```Huobi``` and ```Futures_HuobiDM``` (HTX futures). If a strategy branches on the exchange name, handle both spellings.\\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```javascript\\n/*backtest\\nstart: 2024-05-01 00:00:00\\nend: 2025-02-17 00:00:00\\nperiod: 1d\\nbasePeriod: 1d\\nexchanges: [{\\\"eid\\\":\\\"Futures_Futu\\\",\\\"currency\\\":\\\"STOCK\\\",\\\"fee\\\":[0.03,0.03]}]\\n*/\\n\\nfunction main() {\\n // Set the stock code: Tesla\\n var info = exchange.SetContractType(\\\"TSLA.US\\\")\\n // Contract info: InstrumentID, PriceTick, LotTick, VolumeMultiple, ...\\n Log(\\\"info:\\\", info)\\n // Daily market data at the current backtest time\\n Log(exchange.GetTicker())\\n}\\n```\", \"title\": \"Supported Languages and Exchanges\"}, {\"_src_hash\": \"b0cf39c0614a1fc23e5a75d541ebe4432e02ba326b7520f273d1b87d2b1fbf62\", \"desc\": \"When a backtest finishes, the backtest page shows the profit curve, statistics, status information, logs and account information.\\n\\n### Profit curve\\n\\nWhen the strategy calls ```LogProfit()``` ({@fun/Log/LogProfit LogProfit}), the profit curve consists of the recorded values and the statistics below are computed from that series. When it never calls ```LogProfit()```, the backtest page computes profit and loss from the account snapshots recorded by the engine and draws the curve and computes the statistics from them (using the first exchange account).\\n\\nThe ```profit``` and ```max_drawdown``` returned by the MCP tool ```get_backtest``` come from the values recorded with ```LogProfit()```; ```max_drawdown``` is the largest peak-to-trough fall of that series (an absolute amount, not a ratio). When the strategy has no profit records, ```profit``` is the profit computed by the engine and ```max_drawdown``` is not returned.\\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. |\\n| Win rate (winningRate) | Share of points in the profit series higher than the previous point (the first point is compared with 0). |\\n| Volatility (volatility) | Population standard deviation of each day's profit ÷ initial assets, annualized by multiplying by yearDays. |\\n| Sharpe ratio (sharpeRatio) | (Annualized return − risk-free rate 3%) ÷ volatility; 0 when volatility is 0. |\\n\\n- Max drawdown: maxDrawdownStartTime is the time of the asset peak before the drawdown, maxDrawdownTime the time of the deepest point.\\n- Win rate: it counts profit records, not individual trades.\\n- Volatility: the backtest period is cut into days to compute daily profit; days without profit records count as 0.\\n- yearDays is the number of days per year used for annualization, fixed at 365. 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```javascript\\nfunction returnAnalyze(totalAssets, profits, ts, te, period, yearDays) {\\n // always by day\\n period = 86400000\\n if (profits.length == 0) {\\n return null\\n }\\n var freeProfit = 0.03 // risk-free rate\\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\": \"3c937225a511a52b30837a1be910eb4989f2f83ba9d8e0c8d84279148c026d4b\", \"desc\": \"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 takes effect for backtests that run in the browser: JavaScript, PINE and MyLanguage strategies, and Python and Rust strategies with the \\\"Local\\\" backtest node; otherwise backtests run one at a time. Parameters of referenced templates can be selected for optimization too and are included in the combinations.\\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\": \"d6a6669ff2b981f4f451e7e26ff187cf29508042e3f92620d0c3eb6fa0ba4689\", \"children\": [{\"_src_hash\": \"2249f2bb367b0d8da2bb0aebc7a3d4c2eec893c0253ec2ce73e6da25dd3b5acf\", \"desc\": \"A custom data source returns JSON in one of the two formats below, recognized automatically: simulated-tick backtests use K-line data, real-tick backtests use order book depth and trade data. All values are integers scaled by precision; see \\\"Numeric precision\\\" below.\\n\\n### Simulated tick\\n\\n```json\\n{\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 3,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10\\n },\\n \\\"schema\\\":[\\\"time\\\", \\\"open\\\", \\\"high\\\", \\\"low\\\", \\\"close\\\", \\\"vol\\\"],\\n \\\"data\\\":[\\n [1564315200000, 9531300, 9531300, 9497060, 9497060, 787],\\n [1564316100000, 9495160, 9495160, 9474260, 9489460, 338]\\n ]\\n}\\n```\\n\\n### Real tick\\n\\nThe data includes order book depth as arrays of ```[price, amount]```, with any number of levels: ```asks``` in ascending price order, ```bids``` in descending price order.\\n\\n```json\\n{\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 3,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10\\n },\\n \\\"schema\\\":[\\\"time\\\", \\\"asks\\\", \\\"bids\\\", \\\"trades\\\", \\\"close\\\", \\\"vol\\\"],\\n \\\"data\\\":[\\n [1564315200000, [[9531300, 10]], [[9531300, 10]],\\n [[1564315200000, 0, 9531300, 10]], 9497060, 787],\\n [1564316100000, [[9531300, 10]], [[9531300, 10]],\\n [[1564316100000, 0, 9531300, 10]], 9497060, 787]\\n ]\\n}\\n```\\n\\n### Top-level fields\\n\\n| Field | Description |\\n| - | - |\\n| detail | Details of the requested instrument (currencies, precision, minimum order size...); see \\\"detail field\\\" below |\\n| schema | Attributes of the columns of the ```data``` array, case-sensitive |\\n| data | The data, laid out by the columns in ```schema``` |\\n\\nColumns available in ```schema```: ```time```, ```open```, ```high```, ```low```, ```close```, ```vol```, ```asks```, ```bids```, ```trades```, ```position``` (open interest), ```data``` (custom data). The formats of ```asks```, ```bids``` and ```trades```:\\n\\n| Column | Format | Example (from the real-tick sample) |\\n| - | - | - |\\n| asks / bids | ```[[price, amount], ...]``` | ```[[9531300, 10]]``` |\\n| trades | ```[[time, side, price, amount], ...]```, side 0 = buy, 1 = sell | ```[[1564315200000, 0, 9531300, 10]]``` |\\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 3, so ```9531300``` means a price of 9531.300; ```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; spot and futures of the same exchange use different eids |\\n| symbol | Trading instrument code |\\n| alias | The instrument's symbol 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 increment |\\n| volumeTick | Minimum order quantity increment |\\n| marginLevel | Futures leverage |\\n| contractType | Set to ```swap``` for perpetual contracts; the backtest system then also requests funding rate and price index data |\\n\\n### Funding rates and price index for perpetual contracts\\n\\nWhen backtesting perpetual contracts on futures exchanges, the custom data source must also provide funding rate data and price index data:\\n\\n- The backtest system requests funding rate data only if the ```detail``` of the market data contains ```\\\"contractType\\\": \\\"swap\\\"```, and only when the strategy holds a position in that perpetual contract or calls ```GetFundings()```. If ```swap``` is declared but no funding rate data can be obtained, the backtest fails with ```symbol ... not found```.\\n- Only after receiving funding rate data does the backtest system request price index data.\\n- For funding rate data only the ```open``` column is read as the rate, truncated to the ```priceTick``` in the funding data's ```detail```, so that ```priceTick``` must be small enough (e.g. ```0.00000001```).\\n- Funding rate records are 8 hours apart and, like K-line data, are integers scaled by precision; they can be negative. In the example below ```quotePrecision``` is 8, so ```-16795``` means a funding rate of -0.00016795.\\n\\nFunding rate data (the requested ```symbol``` looks like ```BTC_USDT.funding```):\\n\\n```json\\n{\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Futures_Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT.funding\\\",\\n \\\"alias\\\": \\\"BTC_USDT.funding\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"\\\",\\n \\\"basePrecision\\\": 8,\\n \\\"quotePrecision\\\": 8,\\n \\\"minQty\\\": 1,\\n \\\"maxQty\\\": 10000,\\n \\\"minNotional\\\": 1,\\n \\\"maxNotional\\\": 100000000,\\n \\\"priceTick\\\": 1e-8,\\n \\\"volumeTick\\\": 1e-8,\\n \\\"marginLevel\\\": 10\\n },\\n \\\"schema\\\": [\\\"time\\\", \\\"open\\\", \\\"high\\\", \\\"low\\\", \\\"close\\\", \\\"vol\\\"],\\n \\\"data\\\": [\\n [1584921600000, -16795, -16795, -16795, -16795, 0],\\n [1584950400000, -16294, -16294, -16294, -16294, 0]\\n ]\\n}\\n```\\n\\nExample of a funding rate 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 (the requested ```symbol``` looks like ```BTC_USDT.index```):\\n\\n```json\\n{\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Futures_Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT.index\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"contractType\\\": \\\"index\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 3,\\n \\\"quotePrecision\\\": 1,\\n \\\"minQty\\\": 0.001,\\n \\\"maxQty\\\": 1000,\\n \\\"minNotional\\\": 0,\\n \\\"maxNotional\\\": 1.7976931348623157e+308,\\n \\\"priceTick\\\": 0.1,\\n \\\"volumeTick\\\": 0.001,\\n \\\"marginLevel\\\": 10,\\n \\\"volumeMultiple\\\": 1\\n },\\n \\\"schema\\\": [\\\"time\\\", \\\"open\\\", \\\"high\\\", \\\"low\\\", \\\"close\\\", \\\"vol\\\"],\\n \\\"data\\\": [\\n [1584921600000, 58172, 59167, 56902, 58962, 0],\\n [1584922500000, 58975, 59428, 58581, 59154, 0]\\n ]\\n}\\n```\\n\\nExample of a price index 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.index&to=1611244800&trades=0\\n```\", \"title\": \"Data Format\"}, {\"_src_hash\": \"d9e6c5d0ba915dd1ad151384da5ed15a3a625f39311b9f8ee7c8008ec86bfc10\", \"desc\": \"A minimal custom data source service written in Go, and a test strategy to check it. Steps:\\n\\n1. 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).\\n2. In the backtest configuration, set the exchange's data source (```feeder```) to that URL and backtest the test strategy below.\\n\\nThe service:\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"fmt\\\"\\n \\\"net/http\\\"\\n \\\"encoding/json\\\"\\n)\\n\\nfunc Handle (w http.ResponseWriter, r *http.Request) {\\n // e.g. set on backtest DataSource: http://xxx.xx.x.xx:9090/data\\n\\n // request: GET http://xxx.xx.x.xx:9090/data?custom=0&depth=20&detail=true&eid=OKX\\n // &from=1584921600&period=86400000&round=true&symbol=BTC_USDT&to=1611244800&trades=1\\n // request: GET http://xxx.xx.x.xx:9090/data?custom=0&depth=20&detail=true&eid=Futures_Binance\\n // &from=1599958800&period=3600000&round=true&symbol=BTC_USDT.swap&to=1611244800&trades=0\\n fmt.Println(\\\"request:\\\", r)\\n\\n // response\\n defer func() {\\n // response data\\n /* e.g. data\\n {\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 2,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10\\n },\\n \\\"schema\\\": [\\n \\\"time\\\",\\n \\\"open\\\",\\n \\\"high\\\",\\n \\\"low\\\",\\n \\\"close\\\",\\n \\\"vol\\\"\\n ],\\n \\\"data\\\": [\\n [1610755200000, 3673743, 3795000, 3535780, 3599498, 8634843151],\\n [1610841600000, 3599498, 3685250, 3385000, 3582861, 8015772738],\\n [1610928000000, 3582499, 3746983, 3480000, 3663127, 7069811875],\\n [1611014400000, 3662246, 3785000, 3584406, 3589149, 7961130777],\\n [1611100800000, 3590194, 3641531, 3340000, 3546823, 8936842292],\\n [1611187200000, 3546823, 3560000, 3007100, 3085013, 13500407666],\\n [1611273600000, 3085199, 3382653, 2885000, 3294517, 14297168405],\\n [1611360000000, 3295000, 3345600, 3139016, 3207800, 6459528768],\\n [1611446400000, 3207800, 3307100, 3090000, 3225990, 5797803797],\\n [1611532800000, 3225945, 3487500, 3191000, 3225420, 8849922692]\\n ]\\n }\\n */\\n\\n // /* 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 // 1610755200000: 2021-01-16 08:00:00\\n []int64{1610755200000, 3673743, 3795000, 3535780, 3599498, 8634843151},\\n // 1610841600000: 2021-01-17 08:00:00\\n []int64{1610841600000, 3599498, 3685250, 3385000, 3582861, 8015772738},\\n []int64{1610928000000, 3582499, 3746983, 3480000, 3663127, 7069811875},\\n []int64{1611014400000, 3662246, 3785000, 3584406, 3589149, 7961130777},\\n []int64{1611100800000, 3590194, 3641531, 3340000, 3546823, 8936842292},\\n []int64{1611187200000, 3546823, 3560000, 3007100, 3085013, 13500407666},\\n []int64{1611273600000, 3085199, 3382653, 2885000, 3294517, 14297168405},\\n []int64{1611360000000, 3295000, 3345600, 3139016, 3207800, 6459528768},\\n []int64{1611446400000, 3207800, 3307100, 3090000, 3225990, 5797803797},\\n []int64{1611532800000, 3225945, 3487500, 3191000, 3225420, 8849922692},\\n },\\n }\\n // */\\n\\n /* 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,\\n []interface{}{[]int64{9531300, 10}},\\n []interface{}{[]int64{9531300, 10}},\\n []interface{}{[]int64{1610755200000, 0, 9531300, 10}},\\n 9497060, 787},\\n []interface{}{1610841600000,\\n []interface{}{[]int64{9531300, 15}},\\n []interface{}{[]int64{9531300, 15}},\\n []interface{}{[]int64{1610841600000, 0, 9531300, 11}},\\n 9497061, 789},\\n },\\n }\\n */\\n\\n b, _ := json.Marshal(ret)\\n w.Write(b)\\n }()\\n}\\n\\nfunc main () {\\n fmt.Println(\\\"listen http://localhost:9090\\\")\\n http.HandleFunc(\\\"/data\\\", Handle)\\n http.ListenAndServe(\\\":9090\\\", nil)\\n}\\n```\\n\\nTest strategy (```JavaScript```):\\n\\n```javascript\\n/*backtest\\nstart: 2021-01-16 08:00:00\\nend: 2021-01-22 00:00:00\\nperiod: 1d\\nbasePeriod: 1d\\nexchanges: [{\\\"eid\\\":\\\"OKX\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"feeder\\\":\\\"http://:9090/data\\\"}]\\nargs: [[\\\"number\\\",2]]\\n*/\\n\\nfunction main() {\\n var ticker = exchange.GetTicker()\\n var records = exchange.GetRecords()\\n Log(exchange.GetName(), exchange.GetCurrency())\\n Log(ticker)\\n Log(records)\\n}\\n```\", \"title\": \"Custom Data Source Example\"}], \"desc\": \"The backtest system can use a custom data source instead of the platform's historical data: set the exchange's data source in the backtest configuration to the custom data source (feeder) address, and during the backtest the platform's data server requests that 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 like ```BTC_USDT```, futures like ```BTC_USDT.swap```; funding rate and price index: see below |\\n| eid | Exchange | For example: OKX, Futures_OKX |\\n| round | Data precision | Always ```round=true```: values are integers scaled by precision; see {@backtesting-system/custom-data-source/data-format 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); always 0 in simulated-tick backtests |\\n| from | Start time | Unix timestamp in seconds |\\n| to | End time | Unix timestamp in seconds |\\n| detail | Instrument details | Always ```detail=true```: the response must include the instrument details |\\n| event | Request type | ```feed```: market data requested when the backtest starts; ```fill```: older K-lines when there are not enough bars |\\n| custom | -- | This parameter can be ignored |\\n\\n- Perpetual contract backtests also request funding rate data (```symbol``` like ```BTC_USDT.funding```) and price index data (```symbol``` like ```BTC_USDT.index```); see {@backtesting-system/custom-data-source/data-format Data Format}.\\n- ```event=fill``` requests always carry ```depth=2&trades=0&custom=0```, with ```period``` ```900000``` or ```86400000```.\\n\\nExample requests sent by the backtest system to a custom data source (one for a spot and one for a futures exchange object):\\n\\n```url\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Bitget&event=feed&from=1351641600&period=86400000&round=true&symbol=BTC_USDT&to=1611244800&trades=0\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Futures_OKX&event=feed&from=1351641600&period=86400000&round=true&symbol=BTC_USDT.swap&to=1611244800&trades=0\\n```\", \"title\": \"Custom Data Source\"}, {\"_src_hash\": \"cce13655bfb201a27a4ff2f463b2673745b8e55167aa8974644941c51e821266\", \"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. Source code:\\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 Backtest Configuration and Saving}; the local engines read only some of its keys, see \\\"Differences from cloud backtests\\\" below) 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 *\\n# initialize the engine from the configuration above; exchange, Log, TA etc. become globals\\ntask = VCtx(__doc__)\\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 if r:\\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 a pandas DataFrame of the first exchange account's profit and loss (PnL) and utilization at each snapshot, and ```task.Show()``` plots equity, profit and loss and utilization from the account snapshots; neither depends on ```LogProfit()```.\\n\\n### JavaScript\\n\\n```bash\\nnpm install git+https://github.com/fmzquant/backtest_javascript.git\\n```\\n\\n```javascript\\nvar fmz = require(\\\"fmz\\\")\\nvar task = fmz.VCtx({\\n start: \\\"2026-09-01 00:00:00\\\", end: \\\"2026-09-15 00:00:00\\\", period: \\\"1h\\\", basePeriod: \\\"15m\\\",\\n exchanges: [{eid: \\\"Binance\\\", currency: \\\"BTC_USDT\\\", balance: 10000, stocks: 0}]\\n})\\n// 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 if (r) {\\n LogStatus(_D(), r[r.length - 1].Close)\\n }\\n Sleep(60 * 60 * 1000)\\n }\\n}\\n\\ntry {\\n main()\\n} catch (e) {\\n // 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- Only ```start```, ```end```, ```period```, ```basePeriod``` and ```exchanges``` (with its ```eid```, ```currency```, ```balance```, ```stocks```, ```fee```, ```feeMin```) are read from the comment; ```mode```, ```args```, ```depthDeep```, ```tradesMode```, ```feeder``` and the like are ignored. Without ```basePeriod``` it is derived from ```period``` (1d→1h, 1h→30m, 30m→15m, 15m→5m, 5m→1m); without ```stocks``` the default is 3; without ```fee``` the engine's built-in fee table is used. It is best to write them all out.\\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 {@extended-api-interface/ai-integration 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\": \"9bd67b2520c70019294927f4a1f14930f9db5c9047bda94c765ee56adeb4a418\", \"desc\": \"On the strategy editing page and the backtest page, the shortcuts below switch pages, save the strategy and start a backtest.\\n\\n| Shortcut | Action |\\n| - | - |\\n| ```Ctrl + ,``` | Switch between the strategy editing page and the backtest page (hold ```Ctrl``` and press ```,```) |\\n| ```Ctrl + s``` | Save the strategy |\\n| ```Ctrl + b``` | Start a 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\": \"90a936be8868ffe5af8cbb515dd4b6d6195e2c0fe02db164843f0e4c5394ae7d\", \"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 | Send with ```postMessage(msg)```, read with ```peekMessage(timeout)```; see below the table | Each thread has its own inbox, read in order |\\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\\nSending and receiving messages: ```t.postMessage(msg)``` sends to thread ```t```; inside a thread, ```threading.currentThread().peekMessage(timeout)``` reads the messages it received, and ```peekMessage(-1)``` does not block and returns a null value when there is no message; a child thread sends back to the main thread with ```threading.mainThread().postMessage(msg)```.\\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. There is no fixed limit on the number of threads (the 2000 limit applies only to ```exchange.Go()``` and ```HttpQuery_Go()``` tasks whose results have not been collected).\\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.\", \"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 var close = records[records.length - 1].Close\\n return {symbol: symbol, close: close, ma20: ma[ma.length - 1]}\\n }, symbols[i], PERIOD_H1))\\n }\\n for (var i = 0; i < threads.length; i++) {\\n var r = threads[i].join().ret\\n if (r) {\\n Log(r.symbol, \\\"close:\\\", r.close, \\\"MA20:\\\", r.ma20)\\n }\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"Several threads compute in parallel and the main thread collects the results; the symbol is passed as an argument, so 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 writes the latest price into a shared dictionary and reports errors by message; 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```: the HTTP handler gets the shared 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\": \"bec02afd52b25673a2faaea4588ba32f049c46956aa8009d866d93c7abb4799c\", \"desc\": \"Every live trading has a channel whose ID is the robot ID. A robot publishes data on its own channel with ```SetChannelData()```, and other robots 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 a null value (```null```/```None```). From then on the server pushes the channel's updates to this robot, and later calls return the latest data. A subscriber should start reading at startup and handle null values.\\n- **Subscription limit**: a robot can subscribe to at most 10 different channels (UUID channels below included). Beyond that, the call returns a null value (```null```/```None```) and logs the error ```channel subscriber exceed limit```; the strategy keeps running.\\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 argument and reads this robot's own channel; to read another robot's or a UUID channel use ```GetChannelDataOf(channel ID)```, which returns a ```JsonValue``` (```Null``` on the first call, the parsed value when the data is JSON, otherwise a string).\\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)```. For the request format and delivery rules see {@extended-api-interface/extended-api-interface-details/pub pub}, and {@fun/Storage/GetChannelData GetChannelData}.\\n- **Live trading feature**: channels are meant for communication between robots; do not rely on them in backtests. The current robot ID is available from ```_G()```.\\n- Do not pass keys or other sensitive information through channels.\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var robotId = _G() // current robot ID, which is also this robot'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 robot ID, which is also this robot'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 robot ID, which is also this robot'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\\\": {},\\n \\\"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 // robot 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 + \\\" \\\" +\\n _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 # robot 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(\\n 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\": \"fn main() {\\n // IDs of the robots to subscribe to (change as needed)\\n let channels = [\\\"632799\\\", \\\"632800\\\"];\\n\\n loop {\\n let mut msg = String::new();\\n for ch in channels.iter() {\\n // The first call subscribes and returns Null; later calls return the latest data\\n let state = GetChannelDataOf(*ch);\\n if !state.is_null() {\\n msg += &format!(\\\"Channel {}: #{} {} last price {}\\\\n\\\", ch,\\n state[\\\"updateId\\\"].as_i64().unwrap_or(0),\\n _D(state[\\\"timestamp\\\"].as_i64().unwrap_or(0)),\\n state[\\\"lastPrice\\\"].as_f64().unwrap_or(0.0));\\n } else {\\n msg += &format!(\\\"Channel {}: waiting for data\\\\n\\\", ch);\\n }\\n }\\n LogStatus!(msg);\\n Sleep(5000);\\n }\\n}\", \"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 1, master/follower strategies: the master computes a moving-average crossover signal and publishes it.\"}, {\"examples\": [{\"code\": \"function main() {\\n var masterId = \\\"632799\\\" // robot 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\\\" # robot 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\": \"fn main() {\\n let masterId = \\\"632799\\\"; // robot ID of the master strategy\\n let mut lastSignal = String::new();\\n\\n loop {\\n let data = GetChannelDataOf(masterId);\\n if data.is_null() {\\n LogStatus!(\\\"Waiting for the master strategy signal...\\\");\\n } else {\\n let signal = data[\\\"signal\\\"].as_str().unwrap_or(\\\"\\\").to_string();\\n let symbol = data[\\\"symbol\\\"].as_str().unwrap_or(\\\"BTC_USDT\\\");\\n if signal != lastSignal {\\n let price = data[\\\"price\\\"].as_f64().unwrap_or(0.0);\\n Log!(\\\"New signal:\\\", signal.as_str(), \\\"signal price:\\\", price);\\n if let Ok(ticker) = exchange.GetTicker(symbol) {\\n if signal == \\\"BUY\\\" {\\n let _ = exchange.CreateOrder(symbol, \\\"buy\\\", ticker.Last, 0.01);\\n } else if signal == \\\"SELL\\\" {\\n let _ = exchange.CreateOrder(symbol, \\\"sell\\\", ticker.Last, 0.01);\\n }\\n }\\n lastSignal = signal.clone();\\n }\\n let ts = data[\\\"timestamp\\\"].as_i64().unwrap_or(0);\\n LogStatus!(\\\"Current signal:\\\", signal.as_str(), \\\"signal time:\\\", _D(ts));\\n }\\n Sleep(5000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"Scenario 1, master/follower strategies: the follower reads the signal and places an order when it changes.\"}, {\"examples\": [{\"code\": \"function main() {\\n var monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"] // at most 10\\n\\n while (true) {\\n var table = {\\n type: \\\"table\\\", title: \\\"Strategy status\\\",\\n cols: [\\\"Robot ID\\\", \\\"Status\\\", \\\"Last update\\\", \\\"Symbol\\\", \\\"Last price\\\"], rows: []\\n }\\n for (var i = 0; i < monitorList.length; i++) {\\n var data = GetChannelData(monitorList[i])\\n if (data) {\\n var status = Date.now() - data.timestamp < 120000 ? \\\"running\\\" : \\\"abnormal\\\"\\n table.rows.push([monitorList[i], status, _D(data.timestamp),\\n 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 = {\\n \\\"type\\\": \\\"table\\\", \\\"title\\\": \\\"Strategy status\\\",\\n \\\"cols\\\": [\\\"Robot ID\\\", \\\"Status\\\", \\\"Last update\\\", \\\"Symbol\\\", \\\"Last price\\\"], \\\"rows\\\": []\\n }\\n for robotId in monitorList:\\n data = GetChannelData(robotId)\\n if data:\\n fresh = time.time() * 1000 - data[\\\"timestamp\\\"] < 120000\\n status = \\\"running\\\" if fresh else \\\"abnormal\\\"\\n table[\\\"rows\\\"].append([robotId, status, _D(data[\\\"timestamp\\\"]),\\n 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\": \"fn main() {\\n let monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"]; // at most 10\\n\\n loop {\\n let mut rows = Vec::new();\\n for robotId in monitorList.iter() {\\n let data = GetChannelDataOf(*robotId);\\n if !data.is_null() {\\n let ts = data[\\\"timestamp\\\"].as_i64().unwrap_or(0);\\n let status = if Unix() * 1000 - ts < 120000 { \\\"Running\\\" } else { \\\"Stale\\\" };\\n let price = data[\\\"lastPrice\\\"].as_f64()\\n .map(|p| p.to_string()).unwrap_or(\\\"-\\\".to_string());\\n rows.push(format!(r#\\\"[\\\"{}\\\", \\\"{}\\\", \\\"{}\\\", \\\"{}\\\", \\\"{}\\\"]\\\"#, robotId, status, _D(ts),\\n data[\\\"symbol\\\"].as_str().unwrap_or(\\\"-\\\"), price));\\n } else {\\n rows.push(format!(r#\\\"[\\\"{}\\\", \\\"Waiting for data\\\", \\\"-\\\", \\\"-\\\", \\\"-\\\"]\\\"#, robotId));\\n }\\n }\\n let table = format!(\\n r#\\\"{{\\\"type\\\": \\\"table\\\", \\\"title\\\": \\\"Strategy status\\\",\\n \\\"cols\\\": [\\\"Robot ID\\\", \\\"Status\\\", \\\"Last update\\\", \\\"Symbol\\\", \\\"Last price\\\"],\\n \\\"rows\\\": [{}]}}\\\"#,\\n rows.join(\\\", \\\"));\\n LogStatus!(format!(\\\"`{}`\\\", table));\\n Sleep(10000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"Scenario 2, monitoring several strategies: each strategy publishes its status like the publisher; the monitoring robot 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\": \"0304535c7f5aa4a5d05cf0815562a1e6152be9d3d83d40ab2f139bf1e65ec029\", \"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```javascript\\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\\nFor the parameter syntax (several function names separated by commas, the ```*``` fallback rule, ```\\\"count/burst\\\"``` in ```rate``` mode, window durations and daily resets with ```@HHMM```, the ```delay``` action, deleting rules) see ```exchange.IO(\\\"rate\\\", ...)``` in the {@fun/IO/exchange.IO exchange.IO} category of the syntax manual.\\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``` |\\n| Conditional order queries | ```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```text\\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.\", \"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 20 calls/s on average\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\")\\n // trading: orders (incl. Buy/Sell) and cancels together 5/s; wait when over\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\")\\n // fallback: other functions (GetAccount, GetPositions...) 60/min, aligned to 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 20 calls/s on average\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\")\\n # trading: orders (incl. Buy/Sell) and cancels together 5/s; wait when over\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\")\\n # fallback: other functions (GetAccount, GetPositions...) 60/min, aligned to 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 20 calls/s on average\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\"));\\n // trading: orders (incl. Buy/Sell) and cancels together 5/s; wait when over\\n let _ = exchange.IO((\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\"));\\n // fallback: other functions (GetAccount, GetPositions...) 60/min, aligned to minutes\\n let _ = exchange.IO((\\\"quota\\\", \\\"*\\\", 60, \\\"1m\\\"));\\n\\n loop {\\n let (t, d) = (exchange.GetTicker(\\\"BTC_USDT\\\"), exchange.GetDepth(\\\"BTC_USDT\\\"));\\n if let (Ok(ticker), Ok(depth)) = (t, d) {\\n Log!(\\\"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: market data and trading each share one rule, trading calls wait instead of failing, and every other function 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\": \"60319bd6f5d16aa06a0b4ad709b63a5c3a88a48fa1f2ef182cc7d1a1c98e7c6e\", \"desc\": \"The FMZ Quant Trading Platform supports options trading on the cryptocurrency futures exchanges in the table 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-261225-100000-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 the exchange pages. 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| Exchange object | Pair example | Option code example | GetMarkets lists options |\\n| - | - | - | - |\\n| {@exchanges/cex/deribit Futures_Deribit} | ```BTC_USD``` | ```BTC-25DEC26-100000-C``` | Yes |\\n| {@exchanges/cex/okx Futures_OKCoin} (OKX futures) | ```BTC_USD``` | ```BTC-USD-261225-100000-C``` | No |\\n| {@exchanges/cex/binance Futures_Binance} | ```BTC_USDT``` | ```BTC-261225-100000-C``` | No |\\n| {@exchanges/cex/bybit Futures_Bybit} | ```ETH_USDT``` | ```ETH-25JUN27-2800-C-USDT``` | Yes |\\n| {@exchanges/dex/aevo Futures_Aevo} | ```ETH_USDC``` | ```ETH-25DEC26-3000-C``` | Yes |\\n| {@exchanges/cex/gate Futures_GateIO} | ```BTC_USDT``` | ```BTC_USDT-20261225-100000-C``` | Yes |\\n| {@exchanges/cex/kraken Futures_Kraken} | ```ETH_USD``` | ```OF_ETHUSD_261225_4000_C``` | No |\\n\\nThe expiries and strikes in these codes are examples only; the contracts you can trade are those currently listed by the exchange.\\n\\nThe exact rules differ between exchanges and are documented in the \\\"Options\\\" section of each exchange page: how option codes are written (for example Deribit's combination options, or ```XBT``` for BTC in Kraken codes), where to get option codes when ```exchange.GetMarkets()``` does not list them, order restrictions (some exchanges accept only limit orders and support neither order modification, conditional orders nor ```exchange.SetMarginLevel()```), and whether ```Last``` in the ```Ticker``` falls back to the mark price when there is no trade. Click an exchange name in the table above.\", \"seeAlso\": [\"{@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Futures/exchange.GetPositions exchange.GetPositions}\"], \"title\": \"Options Trading\"}, {\"_src_hash\": \"998ed7c7f4a2db3c34679e0e2be54a0fb73fa440940216df6ff9dc9d62c51791\", \"children\": [{\"_src_hash\": \"a1fbd05bb0baa42bb77347dba600b8b34c49500248edd6f52c31c4755d3d557a\", \"desc\": \"The Uniswap exchange object (```exchange.GetName()``` returns ```Uniswap```) connects to the pools of Uniswap, PancakeSwap or Aerodrome on one EVM chain and maps on-chain swaps to the spot trading functions: check prices with ```exchange.GetTicker()``` and trade with ```exchange.CreateOrder()```, without registering ABIs or encoding contract calls yourself. Routing, quoting, token approval, price protection and sending transactions are handled by the exchange object. The same implementation also comes in two aggregator versions, ```KyberSwap``` and ```OneInch``` (1inch), whose quotes and transaction data come from the aggregator, which splits and routes orders across many DEXs and market makers.\\n\\n### Which exchange object to use\\n\\n| Need | Exchange object |\\n| - | - |\\n| Swap on the pools of a given DEX with control over the route (V2/V3/V4, direct or two-hop) | ```Uniswap```, with DEX set to Uniswap, PancakeSwap or Aerodrome |\\n| Let an aggregator find the best price across DEXs, no API key needed | ```KyberSwap``` |\\n| Let the 1inch aggregator find the best price (needs a 1inch API key) | ```OneInch``` |\\n| Call other contracts, provide liquidity, manage V3 positions, custom transactions | ```Web3```, see {@advanced-topics/web3/ethereum-evm Ethereum (EVM)} |\\n| Swaps on Solana | ```Jupiter```, see {@advanced-topics/web3/solana-swaps-jupiter Solana Swaps (Jupiter)} |\\n\\nA strategy can add several exchange objects that use the same wallet, for example ```Uniswap``` and ```KyberSwap``` to compare prices and ```Web3``` for other on-chain operations.\\n\\n### Configuring the exchange object\\n\\n- ```DEX```: ```Uniswap``` exchange object only: ```Uniswap```, ```PancakeSwap```, ```Aerodrome``` (Base only)\\n- ```Chain```: One exchange object corresponds to one chain; see the table below\\n- ```Private Key```: Wallet private key (hex string). The key can be kept locally on the docker, see {@platform-basics/exchange/local-credential-files Local Credential Files}\\n- ```Rpc Address```: Node address for the chain; selecting a Chain fills in the default nodes (```primary,backup```). Separate several nodes with commas; when one fails or lacks data the next one is used\\n- ```Rpc Api Key```: Node authentication, may be empty. Written as ```Name: value``` it is sent as that request header, otherwise as ```Authorization: Basic ```. ```OneInch``` has no such field\\n- ```1inch Api Key```: ```OneInch``` only, required: apply for it on the 1inch developer portal\\n\\nDEXs and aggregators by chain:\\n\\n| Chain | Uniswap | PancakeSwap | Aerodrome | KyberSwap | OneInch |\\n| - | - | - | - | - | - |\\n| Ethereum | V2, V3, V4 | V2, V3 | — | ✓ | ✓ |\\n| Arbitrum | V3, V4 | V2, V3 | — | ✓ | ✓ |\\n| Base | V3, V4 | V2, V3, Infinity | Slipstream, basic pools | ✓ | ✓ |\\n| BNB Chain | V3, V4 | V2, V3, Infinity | — | ✓ | ✓ |\\n| Unichain | V2, V3, V4 | — | — | ✓ | ✓ |\\n| Polygon | V3, V4 | — | — | ✓ | ✓ |\\n| OP Mainnet | V3, V4 | — | — | ✓ | ✓ |\\n| Robinhood | V2, V3, V4 | — | — | ✓ | — |\\n| Arc | V2, V3, V4 | — | — | — | — |\\n\\n- V4 (Uniswap) and Infinity (PancakeSwap Infinity CL) use only pools without hooks; the native coin takes part in the swap directly, without the wrapped coin.\\n- The wallet needs the chain's native coin to pay gas: ETH or BNB; POL on Polygon (wrapped: WPOL); Arc pays gas in USDC.\\n- The first request checks that the node is on the configured Chain; if not, it reports an error and never sends a transaction to another chain.\\n- The node must be able to return receipts of mined transactions, otherwise order status cannot be queried. publicnode's public Base, BNB Chain and Arbitrum nodes cannot, so do not use them alone; check this when you configure your own node.\\n\\n### Trading pairs\\n\\n- Pairs are written as ```base_quote```, e.g. ```ETH_USDC```, ```UNI_USDT```.\\n- Token names are looked up in the token table first (built-in common tokens such as the native coin, wrapped native coin, USDC and USDT, plus tokens registered with ```exchange.IO(\\\"token\\\", name, contractAddress)```), then in the built-in official token list. If a chain has several tokens with the same name, use the contract address instead, e.g. ```0x1f9840a85d5af5bf1d1762f925bdaddc4201f984_USDC```; a contract address is registered automatically with the decimals read from the chain.\\n- **The native coin and the wrapped coin are two assets**: ```ETH``` and ```WETH```, ```BNB``` and ```WBNB``` are different coins. You cannot place an order between them; convert 1:1 with ```exchange.IO(\\\"wrap\\\", amount)``` and ```exchange.IO(\\\"unwrap\\\", amount)```, which only cost gas.\\n- Chain-specific names: USDT on Unichain and Polygon is ```USDT0```; Robinhood has no USDC or USDT and uses USDG (```ETH_USDG```); on Arc the native balance is USDC and pairs are written ```WETH_USDC```, ```EURC_USDC```.\\n- ```exchange.GetMarkets()``` lists only common pairs; pairs not listed can be traded as well.\\n\\n### Placing orders\\n\\nA DEX has no order book: every order is an on-chain swap executed immediately, either filled in full or reverted in full (losing only gas). There are no partial fills and no resting orders.\\n\\n- **Limit orders**: the limit price is the **worst execution price**. The order is quoted first; if the current price cannot reach the limit, an error is reported and nothing is sent. Otherwise \\\"minimum received / maximum paid\\\" is written into the transaction, and if the price moves before it is mined the swap reverts.\\n- **Market orders**: slippage protection is applied to the quote; the default slippage is 0.5%, changed with ```exchange.IO(\\\"slippage\\\", ratio)```.\\n- **Amount**: for a sell, the amount of base coin to sell; for a limit buy, the amount of base coin to receive; **for a market buy, the amount of quote coin to spend**.\\n- **Aggregators only support exact input**: a limit buy on ```KyberSwap``` or ```OneInch``` is executed as \\\"spend at most amount × price, receive at least amount\\\", so slightly more may be received. Aerodrome's basic pools are also exact-input only, so a limit buy there uses only Slipstream pools.\\n- **Per-order settings**: JSON can be appended to the side parameter, e.g. ```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 to ```v2```, ```v3```, ```v4```, ```hop``` (two hops) or ```direct```. On Aerodrome ```v2``` means basic pools and ```v3``` means Slipstream.\\n- **Approval**: before selling an ERC20 token the allowance is checked; if it is not enough an approval transaction is sent first and mined. V2 and V3 pools are approved to the router; V4 and Infinity go through their Permit2 contracts; aggregators are approved directly to the aggregator's router. By default only the amount needed is approved; ```exchange.IO(\\\"approve\\\", \\\"max\\\")``` switches to unlimited approval.\\n- **Deadline**: a transaction not mined before the deadline (120 seconds by default, changed with ```exchange.IO(\\\"deadline\\\", seconds)```) reverts, so it does not fill after a large price move.\\n\\nBefore placing an order you can quote only with ```exchange.IO(\\\"route\\\", ...)``` (quotes for each candidate route), and build the transaction with the order logic and simulate it on chain with ```exchange.IO(\\\"simulate\\\", ...)```, which costs no gas.\\n\\n### Orders and cancellation\\n\\n- Order IDs look like ```ETH_USDC,0x…```: the pair, a comma and the transaction hash. ```exchange.GetOrder()``` takes the status from the transaction receipt; the order's ```Info``` has ```chainId``` and the chain name ```chain```, which tell which chain an order belongs to when you aggregate or store orders across chains. To query the receipt with ```exchange.IO(\\\"receipt\\\", ...)```, pass the transaction hash after the comma.\\n- ```exchange.GetOrders()``` returns the orders sent in this run that are not mined yet.\\n- ```exchange.CancelOrder()``` sends a replacement transaction with the original order's nonce and waits for the result (up to 30 seconds by default, changed with ```exchange.IO(\\\"cancelWait\\\", seconds)```): if the replacement is mined first it returns ```true```; if the original order is mined first (or was already mined) it returns ```false```; on timeout it returns ```true```, meaning the cancellation has been submitted. ```exchange.GetOrder()``` has the final word: when the original nonce was taken by the replacement, the order shows as canceled.\\n\\n### Differences from centralized exchanges\\n\\n- The bid and ask of ```exchange.GetTicker()``` are executable prices for about 1000 USD; there are no 24-hour statistics on chain. ```exchange.GetDepth()``` is derived from quotes of increasing size, not a real order book.\\n- ```exchange.GetTrades()``` returns recent on-chain trades from the pair's pools; the aggregators (```KyberSwap```, ```OneInch```) do not support it.\\n- ```exchange.GetRecords()```, ```exchange.GetTickers()``` and ```exchange.GetHistoryOrders()``` are not supported.\\n- The 1inch free tier allows 1 request per second; the connector queues requests, so ```exchange.GetDepth()``` takes correspondingly longer.\\n\\nFor the detailed behavior of each function and the parameters and return values of the ```exchange.IO()``` commands (```route```, ```simulate```, ```token```, ```transfer```, ```receipt```, ```wrap```, ```unwrap```, ```approve```, ```slippage```, ```deadline```, ```cancelWait```, ```gasMultiplier```, ```contracts```, ```base```, ```sendBase```, ```address```), see the {@exchanges/dex/uniswap-pancakeswap Uniswap} exchange page of the syntax manual.\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var symbol = \\\"ETH_USDC\\\"\\n exchange.IO(\\\"slippage\\\", 0.003) // market order slippage 0.3%\\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 if (!r || r.best === null) {\\n Log(\\\"no route:\\\", GetLastError())\\n return\\n }\\n Log(\\\"best route:\\\", r.best, \\\"average price:\\\", r.price)\\n\\n // simulate on chain, no gas spent\\n if (!exchange.IO(\\\"simulate\\\", symbol, \\\"sell\\\", 0.1)) {\\n Log(\\\"simulation failed:\\\", GetLastError())\\n return\\n }\\n\\n // market sell 0.1 ETH; the order ID looks like ETH_USDC,0x…\\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 fill price:\\\", o.AvgPrice)\\n break\\n }\\n Sleep(3000)\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"Quote, simulate, then market sell (```ETH_USDC``` on Ethereum; the same code works on ```KyberSwap``` and ```OneInch```). ```CreateOrder``` sends a real transaction.\"}], \"seeAlso\": [\"{@exchanges/dex/uniswap-pancakeswap Uniswap}, {@fun/Trade/exchange.CreateOrder exchange.CreateOrder}, {@fun/Trade/exchange.CancelOrder exchange.CancelOrder}\"], \"title\": \"EVM On-chain Swaps (Uniswap, KyberSwap, 1inch)\"}, {\"_src_hash\": \"b421c5f9d3a3d0ddfee475a44e9d483cd9cf1d2b543ce8f3225e746578a68a63\", \"desc\": \"The Jupiter exchange object (```exchange.GetName()``` returns ```Jupiter```) connects to the Jupiter aggregator on Solana and maps swaps to the spot trading functions. One exchange object corresponds to one Solana wallet: quotes and swap transactions are generated by Jupiter (which splits and routes orders across the many DEXs and market makers on Solana), signed by the docker with the configured private key and broadcast through a Solana node. For swaps on EVM chains see {@advanced-topics/web3/evm-on-chain-swaps-uniswap-kyberswap-1inch EVM On-chain Swaps (Uniswap, KyberSwap, 1inch)}.\\n\\n### Configuring the exchange object\\n\\n- ```Private Key```: Solana wallet private key: the base58 string exported by Phantom or Solflare, or the JSON byte array of a solana-keygen file. The key can be kept locally on the docker, see {@platform-basics/exchange/local-credential-files Local Credential Files}\\n- ```Rpc Address```: Solana RPC nodes, separated by commas; when one fails the next one is used. Defaults to the official public node and publicnode\\n- ```Jupiter Api Key```: Optional. Without it the free ```lite-api.jup.ag``` is used; with it ```api.jup.ag``` is used and the request rate can be raised according to your plan\\n- ```Liquidity Sources```: Optional; restricts the liquidity sources swaps go through, comma-separated: ```pump``` (the pump.fun bonding curve and PumpSwap), ```meteora```, ```raydium```, ```orca```, or Jupiter source names (such as ```Meteora DLMM```). Empty means all sources\\n\\nThe wallet needs SOL for fees: each transaction's base fee and priority fee are paid from the SOL balance (the priority fee cap defaults to 0.001 SOL and is changed with ```exchange.IO(\\\"priorityFee\\\", ...)```). The first time you buy a token, the wallet has to create an account for it, with a deposit of about 0.002 SOL that still belongs to the wallet.\\n\\n### Trading pairs\\n\\n- Pairs are written as ```SOL_USDC```, ```JUP_USDC```, ```BONK_SOL```. SOL is the native coin and is wrapped and unwrapped automatically during swaps.\\n- Built-in common tokens can be written by name. Other tokens can be written as the exact name of a verified token in Jupiter's token list, as the mint address, or registered first with ```exchange.IO(\\\"token\\\", name, mintAddress)```.\\n- Pairs are **not upper-cased**: mint addresses and names such as ```mSOL``` are case-sensitive, so write them as they are, e.g. ```DB5QKorV9KHY54y73h5xWQqYyuD8P3jC1p5Ea8DBpump_SOL```.\\n- ```exchange.GetMarkets()``` lists pairs of the token table's coins against USDC, USDT and SOL; ```exchange.GetAssets()``` lists only the balances of SOL and the token table's tokens.\\n\\n### Orders\\n\\n- Every order is a swap executed immediately. The limit price is the worst execution price, enforced on chain through the slippage setting; if the current quote cannot reach the limit, an error is reported and nothing is sent. Market orders are protected by slippage (0.5% by default, changed with ```exchange.IO(\\\"slippage\\\", ratio)```). For a market buy the amount is the quote coin to spend.\\n- Jupiter simulates the transaction when generating it, so problems such as an insufficient balance are reported when the order is placed.\\n- Order IDs look like ```SOL_USDC,5VERv8…``` (the pair, a comma and the transaction signature). Once confirmed the order is filled, with the filled amount computed from the wallet balances before and after; a transaction that fails on chain shows as canceled (the fee is still paid); a transaction not included within about a minute expires and shows as canceled.\\n- ```exchange.GetOrders()``` returns the swaps sent by this program that are neither confirmed nor expired.\\n- **No cancellation**: a sent Solana transaction cannot be recalled; ```exchange.CancelOrder()``` reports an error and fails. Just wait for the transaction to expire.\\n- ```exchange.GetTrades()```, ```exchange.GetRecords()```, ```exchange.GetTickers()``` and ```exchange.GetHistoryOrders()``` are not supported.\\n\\n### Request rate\\n\\nJupiter limits requests per second and returns 429 beyond the limit. The connector queues requests at the rate set with ```exchange.IO(\\\"rps\\\", ...)``` (1 per second by default), shared by all Jupiter exchange objects in the same docker process. One ```exchange.GetTicker()``` needs two quotes (about 2 seconds), and a 5-level ```exchange.GetDepth()``` about 10 seconds. If you need more speed, get a Jupiter API key and raise ```rps``` according to your plan.\\n\\n### Common commands\\n\\n```route``` (quote only), ```token``` (register tokens), ```transfer``` (send SOL), ```receipt``` (transaction status), ```slippage```, ```priorityFee```, ```dexes``` (change liquidity sources at run time), ```rps```, plus ```base``` (switch nodes) and ```address``` (wallet address). For their parameters and return values and the detailed behavior of each function, see the {@exchanges/dex/jupiter Jupiter} exchange page of the syntax manual.\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n exchange.IO(\\\"slippage\\\", 0.01) // market order slippage 1%\\n\\n var t = exchange.GetTicker(\\\"SOL_USDC\\\")\\n Log(\\\"bid:\\\", t.Buy, \\\"ask:\\\", t.Sell)\\n\\n // quote only: how much USDC selling 0.1 SOL gets\\n var r = exchange.IO(\\\"route\\\", \\\"SOL_USDC\\\", \\\"sell\\\", 0.1)\\n if (!r || r.route === null) {\\n Log(\\\"no route:\\\", GetLastError())\\n return\\n }\\n Log(\\\"receive:\\\", r.quote, \\\"USDC\\\", \\\"average price:\\\", r.price, \\\"route:\\\", r.route.join(\\\" + \\\"))\\n\\n // market sell 0.1 SOL; the order ID looks like SOL_USDC,5VERv8…\\n var id = exchange.CreateOrder(\\\"SOL_USDC\\\", \\\"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 fill price:\\\", o.AvgPrice)\\n break\\n }\\n Sleep(2000)\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"Quote, then market sell. ```CreateOrder``` sends a real transaction.\"}], \"seeAlso\": [\"{@exchanges/dex/jupiter Jupiter}, {@fun/Trade/exchange.CreateOrder exchange.CreateOrder}\"], \"title\": \"Solana Swaps (Jupiter)\"}, {\"_src_hash\": \"bea9dfb6eb7b49d544f90b87579faebe520279e015fa2a4409b94fd53df41a45\", \"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 {@exchanges/custom/web3 Web3} exchange page of the syntax manual.\\n\\nIf you only want to swap tokens on a DEX, use the ```Uniswap```, ```KyberSwap``` or ```OneInch``` exchange object (see {@advanced-topics/web3/evm-on-chain-swaps-uniswap-kyberswap-1inch EVM On-chain Swaps (Uniswap, KyberSwap, 1inch)}): 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- ```ChainType```: ```ETH```: Ethereum and all EVM-compatible chains; ```TRON```: TRON, see {@advanced-topics/web3/tron 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 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 {@exchanges/custom/web3/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```javascript\\nexchange.IO(\\\"api\\\", \\\"eth\\\", \\\"eth_getBalance\\\", wallet, \\\"latest\\\") // native balance (hex integer)\\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```javascript\\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 a null value and ```GetLastError()``` holds the reason given by the contract.\\n\\nTaking approve as an example:\\n\\n```javascript\\nvar amount = exchange.IO(\\\"toUnits\\\", \\\"100\\\", tokenAddress) // 100 tokens, 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- ```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 a null 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 // the contract to approve, Uniswap SwapRouter02 here\\n var spender = \\\"0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45\\\"\\n var wallet = exchange.IO(\\\"address\\\")\\n\\n // balances: standard ERC20 methods need no ABI registration\\n var wei = exchange.IO(\\\"api\\\", \\\"eth\\\", \\\"eth_getBalance\\\", wallet, \\\"latest\\\")\\n var eth = exchange.IO(\\\"fromUnits\\\", wei, 18)\\n var usdcBalance = exchange.IO(\\\"fromUnits\\\", exchange.IO(\\\"api\\\", usdc, \\\"balanceOf\\\", wallet), usdc)\\n Log(\\\"ETH:\\\", eth, \\\"USDC:\\\", usdcBalance)\\n\\n // 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\": \"Query balances, approve and wait for the transaction (USDC on Ethereum mainnet); this code sends a real transaction and spends gas.\"}], \"seeAlso\": [\"{@exchanges/custom/web3 Web3}, {@fun/IO/exchange.IO exchange.IO}\"], \"title\": \"Ethereum (EVM)\"}, {\"_src_hash\": \"d514a68d9468a1e7c4d86f29034f47346e3a00bd7f4d2976c0b738617134fea3\", \"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 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- ```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 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```javascript\\n// USDT (TRC20) contract\\nvar usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\nLog(exchange.IO(\\\"api\\\", usdt, \\\"balanceOf\\\", exchange.IO(\\\"address\\\"))) // on-chain integer, 6 decimals\\n```\\n\\nEncoding and decoding work as on Ethereum; address arguments can be written directly as ```T``` addresses:\\n\\n```javascript\\nexchange.IO(\\\"encode\\\", \\\"address\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\")\\n// 000000000000000000000000a614f803b6fd780986a42c78ec9c7f77e6ded13c\\nexchange.IO(\\\"encodePacked\\\", \\\"address\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\")\\n// a614f803b6fd780986a42c78ec9c7f77e6ded13c\\nexchange.IO(\\\"decode\\\", \\\"string\\\",\\n \\\"0000000000000000000000000000000000000000000000000000000000000020\\\" +\\n \\\"000000000000000000000000000000000000000000000000000000000000000a\\\" +\\n \\\"5465746865722055534400000000000000000000000000000000000000000000\\\")\\n// Tether USD\\n```\\n\\n### Calling TRON node methods\\n\\n```exchange.IO(\\\"api\\\", \\\"tron\\\", method, ...args)``` calls TRON node methods; method names are case-insensitive (except ```send```, which must be lower case). 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 signature, argument values (see below the table) | Read-only contract call; the result is in ```constant_result``` |\\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\\nFor ```TriggerConstantContract```, the method signature includes the parameter types (e.g. ```\\\"balanceOf(address)\\\"```) and the argument values are a JSON array string (e.g. ```'[\\\"T...\\\"]'```, an empty string for no arguments); the returned ```constant_result``` holds hex strings that can be decoded with ```exchange.IO(\\\"decode\\\", ...)```.\\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```, ```contracts``` and ```sendBase```. Multiple fallback nodes also only apply to Ethereum: TRON takes a single node address, and a comma-separated list of nodes reports an error. 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```javascript\\nvar usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\nvar raw = exchange.IO(\\\"api\\\", usdt, \\\"balanceOf\\\", exchange.IO(\\\"address\\\"))\\nLog(exchange.IO(\\\"fromUnits\\\", raw, usdt)) // readable amount, using 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 {@exchanges/custom/web3 Web3} exchange page 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\": \"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, `[{\\n \\\"inputs\\\": [{\\n \\\"components\\\": [\\n {\\\"internalType\\\": \\\"address\\\", \\\"name\\\": \\\"target\\\", \\\"type\\\": \\\"address\\\"},\\n {\\\"internalType\\\": \\\"bytes\\\", \\\"name\\\": \\\"callData\\\", \\\"type\\\": \\\"bytes\\\"}\\n ],\\n \\\"internalType\\\": \\\"struct TronMulticall.Call[]\\\", \\\"name\\\": \\\"calls\\\", \\\"type\\\": \\\"tuple[]\\\"\\n }],\\n \\\"name\\\": \\\"aggregate\\\",\\n \\\"outputs\\\": [\\n {\\\"internalType\\\": \\\"uint256\\\", \\\"name\\\": \\\"blockNumber\\\", \\\"type\\\": \\\"uint256\\\"},\\n {\\\"internalType\\\": \\\"bytes[]\\\", \\\"name\\\": \\\"returnData\\\", \\\"type\\\": \\\"bytes[]\\\"}\\n ],\\n \\\"stateMutability\\\": \\\"view\\\", \\\"type\\\": \\\"function\\\"\\n }]`)\\n var ret = exchange.IO(\\\"api\\\", multicall, \\\"aggregate\\\", calls)\\n Log(\\\"name:\\\", exchange.IO(\\\"decode\\\", \\\"string\\\", ret.returnData[0]))\\n Log(\\\"decimals:\\\", exchange.IO(\\\"decode\\\", \\\"uint8\\\", ret.returnData[1]))\\n Log(\\\"balanceOf:\\\", exchange.IO(\\\"decode\\\", \\\"uint256\\\", ret.returnData[2]))\\n}\", \"lang\": \"javascript\"}], \"value\": \"Read several contract methods at once with a Multicall contract.\"}], \"seeAlso\": [\"{@exchanges/custom/web3 Web3}, {@fun/IO/exchange.IO exchange.IO}\"], \"title\": \"TRON\"}], \"desc\": \"On-chain trading: which exchange object to use.\\n\\n| Need | Exchange object | Notes |\\n| - | - | - |\\n| Swap tokens on DEXs of EVM chains | ```Uniswap``` (Uniswap, PancakeSwap, Aerodrome), ```KyberSwap```, ```OneInch``` (1inch) | Trade with the spot trading functions; see {@advanced-topics/web3/evm-on-chain-swaps-uniswap-kyberswap-1inch EVM On-chain Swaps (Uniswap, KyberSwap, 1inch)} |\\n| Swap tokens on Solana | ```Jupiter``` | See {@advanced-topics/web3/solana-swaps-jupiter Solana Swaps (Jupiter)} |\\n| Swap on several chains through the OKX DEX aggregator | ```OKX_DEX``` | Mnemonic phrase; pairs are ```{chainIndex}:{token}_USD``` (case-sensitive token names); see {@exchanges/dex/okx-dex OKX_DEX} |\\n| Read on-chain data, call smart contracts, send custom transactions | ```Web3``` | Supports Ethereum and other EVM-compatible chains (see {@advanced-topics/web3/ethereum-evm Ethereum (EVM)}) and TRON (see {@advanced-topics/web3/tron TRON}) |\\n\\nOn-chain exchanges such as Hyperliquid, Lighter, EdgeX, Aster and Polymarket are used with the standard trading functions just like centralized exchanges; for their configuration see the exchange pages under {@exchanges/dex Decentralized Exchanges} and {@exchanges/prediction Prediction Markets} in the syntax manual.\", \"title\": \"Web3\"}], \"desc\": \"Advanced usage: JavaScript multi-threading, communication between robots, API rate limiting, options trading and on-chain trading with Web3.\", \"title\": \"Advanced Topics\"}, {\"_src_hash\": \"1301895a5369c6fe483e8877e0db074cb786721aa4d6a1cace6f2474b0484a85\", \"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\": \"1224f4c59c0614d4497b525f531569ec49313acdfa1f5a5ece1a7b098d8a03ae\", \"children\": [{\"_src_hash\": \"29f4ceb925fc7c3bc4bc9bf621087a58b098ad1d271885f327eb3dc337c05b8b\", \"desc\": \"What can be used in formulas of the alpha factor analysis tool. Expressions are case-insensitive; below, ```x``` and ```y``` are time series, ```d``` is a number of periods, and ```{}``` is a placeholder.\\n\\n### Operators\\n\\n```+```, ```-```, ```*```, ```/```, ```>``` and ```<``` have their standard meaning; ```==``` tests equality, ```||``` is logical or, and ```x ? y : z``` is the ternary conditional operator.\\n\\n### Functions\\n\\n| Function | Description |\\n| - | - |\\n| ```abs(x)```, ```log(x)```, ```sign(x)``` | Absolute value, logarithm, sign |\\n| ```rank(x)``` | Cross-sectional percentile rank; needs a pool of instruments, and with a single one returns the value unchanged |\\n| ```delay(x, d)``` | Value of x d periods ago |\\n| ```sma(x, d)``` | Simple moving average of x over d periods |\\n| ```correlation(x, y, d)``` | Correlation of x and y over the past d periods |\\n| ```covariance(x, y, d)``` | Covariance of x and y over the past d periods |\\n| ```scale(x, a)``` | Normalize so that ```sum(abs(x)) = a``` (a defaults to 1) |\\n| ```delta(x, d)``` | Current value of x minus its value d periods ago |\\n| ```signedpower(x, a)``` | ```x^a``` |\\n| ```decay_linear(x, d)``` | Weighted moving average of x over d periods with weights d, d-1, …, 1 (normalized) |\\n| ```indneutralize(x, g)``` | Neutralize by industry classification g; not supported yet |\\n| ```ts_{O}(x, d)``` | Apply operation O (min, max, ..., see the rows below) to the past d periods of x; d is converted to an integer |\\n| ```ts_min(x, d)```, ```min(x, d)``` | Minimum over the past d periods |\\n| ```ts_max(x, d)```, ```max(x, d)``` | Maximum over the past d periods |\\n| ```ts_argmin(x, d)``` | Position of ```ts_min(x, d)``` |\\n| ```ts_argmax(x, d)``` | Position of ```ts_max(x, d)``` |\\n| ```ts_rank(x, d)``` | Rank (percentile) of x within the past d periods |\\n| ```sum(x, d)``` | Sum over the past d periods |\\n| ```product(x, d)``` | Product over the past d periods |\\n| ```stddev(x, d)``` | Standard deviation over the past d periods |\", \"title\": \"Functions and Operators\"}, {\"_src_hash\": \"4a88db6f4428de6c065d5828235841866db21444d1d8695c67c3425aa5dfbb75\", \"desc\": \"Market data that formulas can refer to. Input data is case-insensitive and defaults to the instrument selected on the web page; an instrument can also be given directly, e.g. ```binance.ada_bnb```.\\n\\n| Data | Description |\\n| - | - |\\n| ```returns``` | Return of the close price |\\n| ```open```, ```close```, ```high```, ```low```, ```volume``` | Open, close, high, low and volume of the period |\\n| ```vwap``` | Volume-weighted average price; not implemented yet, currently the close price |\\n| ```cap``` | Total market capitalization; not implemented yet |\\n| ```IndClass``` | Industry classification; not implemented yet |\", \"title\": \"Input Data\"}], \"desc\": \"The [alpha factor analysis tool](https://www.fmz.com/m/alpha) computes formulas over market time series quickly, to test trading ideas. The formulas follow the market calculation methods of ```worldquant```'s public [```alpha101```](https://github.com/yli188/WorldQuant_alpha101_code/blob/master/101%20Formulaic%20Alphas.pdf), are largely compatible with its syntax (unimplemented parts are noted) and add enhancements.\\n\\nOne formula can output several results at once when written as a list: for example ```[sma(close, 10), sma(high, 30)]``` plots two lines on the chart. Without time series data the tool also works as a simple calculator. The functions, operators and available input data are described in the two sections below.\", \"title\": \"Alpha Factor Analysis Tool\"}], \"desc\": \"Two tools for researching market data, the data explorer for querying and visualizing financial data with SQL and the alpha factor analysis tool for computing and testing factors with formulas.\", \"title\": \"Data and Research\"}, {\"_src_hash\": \"c0951478a97a49a90041465ae83daf220c1bc78254d3b21603e1e3722e6f66a0\", \"children\": [{\"_src_hash\": \"92a8753ea3f69ec0826e043cfaf7b4cf7054619d7e817da600e21506654c429f\", \"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```text\\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, robots, dockers and exchange accounts; logs, messages, account summary (no secrets) | 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/\\\" \\\\\\n --header \\\"Authorization: Bearer \\\"\\n```\\n\\n```json\\n{\\n \\\"mcpServers\\\": {\\n \\\"fmz\\\": {\\n \\\"url\\\": \\\"https://www.fmz.com/api/mcp/\\\",\\n \\\"headers\\\": {\\\"Authorization\\\": \\\"Bearer \\\"}\\n }\\n }\\n}\\n```\\n\\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- ```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-interface/extended-api-interface-details Extended API} for scripts and schedulers; prefer MCP wherever it can be used.\"], \"title\": \"AI Integration\"}, {\"_src_hash\": \"a275a8345dd820a92b88605d8cc451480d195c003aec84aa16891f9787636683\", \"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 {@extended-api-interface/ai-integration AI Integration}). Besides method names (tool names for MCP), permissions can be granted by category: ```read```, ```backtest```, ```write```, ```trade```, ```danger``` (see the AI Integration page), and ```!name``` excludes as well. Categories apply to MCP tools and extended API methods alike. The categories of the extended API methods:\\n\\n- ```read```: ```GetAccount```, ```GetExchangeList```, ```GetNodeList```, ```GetPlatformList```, ```GetRobotGroupList```, ```GetRobotList```, ```GetRobotDetail```, ```GetRobotLogs```, ```GetStrategyList```;\\n- ```trade```: ```NewRobot```, ```RestartRobot```, ```StopRobot```, ```CommandRobot```, ```PluginRun```;\\n- ```danger```: ```DeleteRobot```, ```DeleteNode```.\\n\\nOrder of evaluation: an explicitly listed method name (including a ```!name``` exclusion) comes first, then the category, then ```*```. For example, a key with just ```read``` can call ```GetRobotList``` but not ```NewRobot```; ```*,!trade``` allows every method outside the ```trade``` category.\\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\": \"fde6b5663bfb1eb4d5c366de215fda4c51b4a23eeb6ca0bb0ea01a6d90305ebb\", \"children\": [{\"_src_hash\": \"96d0bc6fd9cc1d6ce861d136b00ad7d63aafe7389db46b840a745fdf7c758be9\", \"desc\": \"Signature authentication signs the request parameters with an MD5 hash that includes the ```SecretKey```, so the ```SecretKey``` itself never travels over the network; programs calling the extended API should use it.\\n\\n### 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 or an object, see below the table); ```[]``` when omitted. |\\n| nonce | Millisecond timestamp, within 1 hour of server time and greater than this API key's previous ```nonce```. |\\n| sign | Signature, computed as described below. |\\n\\n```args``` is either an array in parameter order (e.g. ```[]```, ```[123, \\\"ok\\\"]```) or an object keyed by parameter name (e.g. ```{\\\"robotId\\\": 123}```); see {@extended-api-interface/extended-api-interface-details Extended API Interface Details}. The 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: robots labeled member2\\nprint(api('CommandRobot', 123, 'ok')) # Send an interactive command to robot 123\\nprint(api('GetRobotDetail', 123)) # Details of robot 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 robot 123 with a new configuration; settings: see 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\": \"Token Authentication\"}, {\"_src_hash\": \"31ae9150f6b3a19fcfd926139a8891a4e708a491bd12e022fbf3954595529293\", \"desc\": \"Puts the ```secret_key``` into the request parameters instead of computing a signature. 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 {@extended-api-interface/create-apikey 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 robot 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 robot as the interactive command. The body must be JSON or plain text, not form-encoded (a body sent with ```Content-Type: application/x-www-form-urlencoded``` is consumed as a form first and the command becomes an empty string). 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 robot ID and the command is an empty string.\\n\\nSimulating a TradingView webhook alert:\\n\\n```javascript\\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 var url = \\\"https://www.fmz.com/api/v1?access_key=xxx&secret_key=yyy\\\" +\\n \\\"&method=CommandRobot&args=%5B186515%2C+%22%22%5D\\\"\\n return HttpQuery(url, options)\\n}\\n```\\n\\nThe content of the TradingView alert message box is the request body:\\n\\n- JSON format:\\n\\n ![TradingView alert message (JSON format)](/upload/asset/16d8a37ef80d9ccd0079.png)\\n\\n ```plaintext\\n {\\\"close\\\": {{close}}, \\\"name\\\": \\\"aaa\\\"}\\n ```\\n\\n The robot with ID ```186515``` receives the interactive command ```{\\\"close\\\": 39773.75, \\\"name\\\": \\\"aaa\\\"}```.\\n\\n- Text format:\\n\\n ![TradingView alert message (text format)](/upload/asset/16d8a506dfbb6c60a077.png)\\n\\n ```plaintext\\n BTCUSDTPERP Crossing 39700.00 close: {{close}}\\n ```\\n\\n The robot 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: signature authentication and direct authentication.\\n\\n- {@extended-api-interface/authentication-methods/token-authentication Signature authentication}: the request parameters are signed with the ```SecretKey```, which itself never travels over the network. Programs should use this method.\\n- {@extended-api-interface/authentication-methods/direct-verification 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\": \"6a2d58daf6dc6c8763f756b98d1957f82a86d053bf7228b8891d392196c1eb16\", \"children\": [{\"_src_hash\": \"e4a4f1a5802b3e0227a5f5943605f259aacf426046eb4b71410ec67a86b079c9\", \"attrs\": [{\"info\": \"Account balance in USD, as an integer scaled by 1e8; divide by 1e8 for the actual value (229.44702436 in the example).\", \"name\": \"balance\", \"type\": \"number\"}, {\"info\": \"Total amount spent, in the same unit and scaling as ```balance```.\", \"name\": \"consumed\", \"type\": \"number\"}, {\"info\": \"User name.\", \"name\": \"username\", \"type\": \"string\"}, {\"info\": \"Account email.\", \"name\": \"email\", \"type\": \"string\"}, {\"info\": \"Account UID.\", \"name\": \"uid\", \"type\": \"string\"}], \"desc\": [\"Gets the account information of the account that owns the API key, including the balance and the total amount spent.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('GetAccount')\\nprint(r['data']['result']['balance'] / 1e8) # output: 229.44702436 (USD)\", \"lang\": \"python\"}], \"value\": \"Query the account balance.\"}], \"isChildren\": true, \"remarks\": [\"### Example response\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"balance\\\": 22944702436,\\n \\\"concurrent\\\": 0,\\n \\\"consumed\\\": 211092719653,\\n \\\"email\\\": \\\"123@qq.com\\\",\\n \\\"openai\\\": false,\\n \\\"settings\\\": {},\\n \\\"sns\\\": {\\\"wechat\\\": true},\\n \\\"uid\\\": \\\"105ea6e51bcc177926a10fdbb7e2a1d6\\\",\\n \\\"username\\\": \\\"abc\\\"\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"On success ```data.result``` is the account information; its fields are in the attributes table below.\", \"type\": \"object\"}], \"title\": \"GetAccount\"}, {\"_src_hash\": \"234ebad828f5478dcc8e2627c7faaeaf6ed15a0a0707632f80b04e6c97f22ff2\", \"args\": [{\"info\": \"Paging offset, 0 by default.\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Page size; omitted or less than or equal to 0 returns all.\", \"name\": \"limit\", \"required\": false, \"type\": \"number\"}], \"attrs\": [{\"info\": \"Total number of dockers (public dockers included).\", \"name\": \"all\", \"type\": \"number\"}, {\"info\": \"Array of dockers; the fields of each element are in the rows below (self-explanatory fields are not listed).\", \"name\": \"nodes\", \"type\": \"array\"}, {\"info\": \"Docker ID, the ```node``` of a robot configuration.\", \"name\": \"nodes[].id\", \"type\": \"number\"}, {\"info\": \"Version number.\", \"name\": \"nodes[].build\", \"type\": \"string\"}, {\"info\": \"Detailed version information of the docker.\", \"name\": \"nodes[].version\", \"type\": \"string\"}, {\"info\": \"Whether the docker is online.\", \"name\": \"nodes[].online\", \"type\": \"bool\"}, {\"info\": \"```true``` for a private docker, ```false``` for a public one.\", \"name\": \"nodes[].is_owner\", \"type\": \"bool\"}, {\"info\": \"```0``` for a private docker, ```1``` for a public one.\", \"name\": \"nodes[].public\", \"type\": \"number\"}, {\"info\": \"Load: the number of strategy instances running on the docker.\", \"name\": \"nodes[].loaded\", \"type\": \"number\"}, {\"info\": \"City.\", \"name\": \"nodes[].city\", \"type\": \"string\"}, {\"info\": \"Region.\", \"name\": \"nodes[].region\", \"type\": \"string\"}, {\"info\": \"Whether the offline alert is on; ```0``` means off.\", \"name\": \"nodes[].wd\", \"type\": \"number\"}], \"desc\": [\"Gets the dockers the account can use, including its own dockers and the platform's public dockers.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('GetNodeList')\\nfor node in r['data']['result']['nodes']:\\n print(node['id'], node['name'], node['online'])\", \"lang\": \"python\"}], \"value\": \"List all dockers and whether they are online.\"}], \"isChildren\": true, \"remarks\": [\"Dockers rented with one click have extra fields starting with ```ecs_``` and ```unit_```, recording the server's provider, configuration and state, and the billing period and price.\", \"### Example response\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 1,\\n \\\"nodes\\\": [{\\n \\\"build\\\": \\\"3.7\\\",\\n \\\"city\\\": \\\"...\\\",\\n \\\"created\\\": \\\"2024-11-08 09:21:08\\\",\\n \\\"date\\\": \\\"2024-11-08 16:37:16\\\",\\n \\\"forward\\\": \\\"...\\\",\\n \\\"guid\\\": \\\"...\\\",\\n \\\"host\\\": \\\"node.fmz.com:9902\\\",\\n \\\"id\\\": 123,\\n \\\"ip\\\": \\\"...\\\",\\n \\\"is_owner\\\": true,\\n \\\"loaded\\\": 0,\\n \\\"name\\\": \\\"MacBook-Pro-2.local\\\",\\n \\\"online\\\": true,\\n \\\"os\\\": \\\"darwin/amd64\\\",\\n \\\"peer\\\": \\\"...\\\",\\n \\\"public\\\": 0,\\n \\\"region\\\": \\\"...\\\",\\n \\\"tunnel\\\": false,\\n \\\"version\\\": \\\"...\\\",\\n \\\"wd\\\": 0\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"On success ```data.result``` holds the docker count ```all``` and the docker array ```nodes```; fields are in the attributes table below.\", \"type\": \"object\"}], \"title\": \"GetNodeList\"}, {\"_src_hash\": \"86b2c9626cc310581553413e6b19777c46c079e0f7c41d59e9a75aa22db1f8a0\", \"args\": [{\"info\": \"ID of the docker to delete; see ```GetNodeList```.\", \"name\": \"nid\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"Deletes a docker of the account; an online docker is forced to log out and all robots on it become \\\"strategy error\\\". Deletion cannot be undone.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('DeleteNode', 123)\\nprint(r) # output: {'code': 0, 'data': {'result': True, 'error': None}}\", \"lang\": \"python\"}], \"value\": \"Delete the docker with ID 123.\"}], \"isChildren\": true, \"returns\": [{\"info\": \"```data.result``` is ```true``` when the docker record was deleted: the platform forces the online docker to log out and sets all robots on it to \\\"strategy error\\\" (status code ```5```). It is ```false``` when the docker does not exist, does not belong to the account, or cannot be forced to log out.\", \"type\": \"bool\"}], \"title\": \"DeleteNode\"}, {\"_src_hash\": \"7da6ce4b58766be97c8d56059c9240e023547934a519e9e31c989ef38dd2bcb3\", \"args\": [{\"info\": \"```true``` returns only summary information, without ```meta``` and ```stocks```; ```false``` returns everything.\", \"name\": \"isSummary\", \"required\": true, \"type\": \"bool\"}], \"attrs\": [{\"info\": \"Exchange ID, e.g. ```Futures_Binance```; used when a robot configuration passes an exchange configuration directly.\", \"name\": \"exchanges[].eid\", \"type\": \"string\"}, {\"info\": \"Display name, written ```Chinese|English```.\", \"name\": \"exchanges[].name\", \"type\": \"string\"}, {\"info\": \"Category.\", \"name\": \"exchanges[].category\", \"type\": \"string\"}, {\"info\": \"Metadata of the exchange's configuration fields (JSON text), returned only when ```isSummary``` is ```false```; the field names of ```meta``` in a robot configuration come from here.\", \"name\": \"exchanges[].meta\", \"type\": \"string\"}, {\"info\": \"Common trading pairs, comma-separated, returned only when ```isSummary``` is ```false```.\", \"name\": \"exchanges[].stocks\", \"type\": \"string\"}], \"desc\": [\"Gets the exchanges the platform supports and the configuration fields each of them needs.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('GetExchangeList', True)\\nfor e in r['data']['result']['exchanges']:\\n print(e['eid'], e['name'])\", \"lang\": \"python\"}], \"value\": \"List the supported exchange IDs and names (summary).\"}], \"isChildren\": true, \"remarks\": [\"### Example response (isSummary false)\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"exchanges\\\": [{\\n \\\"category\\\": \\\"加密货币||Crypto\\\",\\n \\\"eid\\\": \\\"Futures_Binance\\\",\\n \\\"id\\\": 74,\\n \\\"logo\\\": \\\"/upload/asset/d8d84b23e573e9326b99.svg\\\",\\n \\\"meta\\\": \\\"[...]\\\",\\n \\\"name\\\": \\\"币安期货|Futures_Binance\\\",\\n \\\"priority\\\": 200,\\n \\\"stocks\\\": \\\"BTC_USDT,ETH_USDT,ETH_USD\\\",\\n \\\"website\\\": \\\"https://accounts.binance.com/zh-TC/register?ref=45110270\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n```meta``` is JSON text; parsed, it is an array of configuration fields:\\n\\n```json\\n[\\n {\\\"desc\\\": \\\"Access Key\\\", \\\"qr\\\": \\\"apiKey\\\", \\\"required\\\": true, \\\"type\\\": \\\"string\\\",\\n \\\"name\\\": \\\"AccessKey\\\", \\\"label\\\": \\\"Access Key\\\"},\\n {\\\"encrypt\\\": true, \\\"qr\\\": \\\"secretKey\\\", \\\"name\\\": \\\"SecretKey\\\", \\\"required\\\": true,\\n \\\"label\\\": \\\"Secret Key\\\", \\\"type\\\": \\\"password\\\", \\\"desc\\\": \\\"Secret Key\\\"}\\n]\\n```\", \"### Example response (isSummary true)\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"exchanges\\\": [{\\n \\\"category\\\": \\\"加密货币||Crypto\\\",\\n \\\"eid\\\": \\\"Futures_Binance\\\",\\n \\\"id\\\": 74,\\n \\\"logo\\\": \\\"/upload/asset/d8d84b23e573e9326b99.svg\\\",\\n \\\"name\\\": \\\"币安期货|Futures_Binance\\\",\\n \\\"priority\\\": 200,\\n \\\"website\\\": \\\"https://accounts.binance.com/zh-TC/register?ref=45110270\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"On success ```data.result.exchanges``` is the array of exchanges; fields are in the attributes table below.\", \"type\": \"object\"}], \"title\": \"GetExchangeList\"}, {\"_src_hash\": \"eda255751255f08de1b506a603385d15ec0fc106dd6d836e2c504bc719e12e03\", \"args\": [{\"info\": \"Paging offset, 0 by default.\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Page size; omitted or less than or equal to 0 returns all.\", \"name\": \"limit\", \"required\": false, \"type\": \"number\"}], \"attrs\": [{\"info\": \"Number of exchange accounts added.\", \"name\": \"all\", \"type\": \"number\"}, {\"info\": \"Exchange account ID, the ```pid``` in the ```exchanges``` of a robot configuration.\", \"name\": \"platforms[].id\", \"type\": \"number\"}, {\"info\": \"Exchange ID, used in some configurations and parameters.\", \"name\": \"platforms[].eid\", \"type\": \"string\"}, {\"info\": \"The label set when the account was added.\", \"name\": \"platforms[].label\", \"type\": \"string\"}, {\"info\": \"Common trading pairs.\", \"name\": \"platforms[].stocks\", \"type\": \"array\"}], \"desc\": [\"Gets the exchange accounts added to the account.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('GetPlatformList')\\nfor p in r['data']['result']['platforms']:\\n print(p['id'], p['eid'], p['label'])\", \"lang\": \"python\"}], \"value\": \"List the added exchange accounts to get the ```pid``` used in robot configurations.\"}], \"isChildren\": true, \"remarks\": [\"### Example response\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 2,\\n \\\"platforms\\\": [{\\n \\\"category\\\": \\\"加密货币||Crypto\\\",\\n \\\"date\\\": \\\"2023-12-07 13:44:52\\\",\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"id\\\": 123,\\n \\\"label\\\": \\\"Binance\\\",\\n \\\"logo\\\": \\\"...\\\",\\n \\\"name\\\": \\\"币安现货|Binance\\\",\\n \\\"stocks\\\": [\\\"BTC_USDT\\\", \\\"LTC_USDT\\\", \\\"ETH_USDT\\\", \\\"ETC_USDT\\\",\\n \\\"BTC_TUSD\\\", \\\"ETH_TUSD\\\", \\\"BNB_TUSD\\\"],\\n \\\"website\\\": \\\"...\\\"\\n }, {\\n \\\"category\\\": \\\"通用协议|Custom Protocol\\\",\\n \\\"date\\\": \\\"2020-11-09 11:23:48\\\",\\n \\\"eid\\\": \\\"Exchange\\\",\\n \\\"id\\\": 123,\\n \\\"label\\\": \\\"XX exchange REST protocol\\\",\\n \\\"logo\\\": \\\"...\\\",\\n \\\"name\\\": \\\"通用协议|Custom Protocol\\\",\\n \\\"stocks\\\": [\\\"BTC_USDT\\\", \\\"ETH_USDT\\\"],\\n \\\"website\\\": \\\"\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"On success ```data.result``` holds the account count ```all``` and the array of exchange accounts ```platforms```; fields are in the attributes table below.\", \"type\": \"object\"}], \"title\": \"GetPlatformList\"}, {\"_src_hash\": \"024bdcaaef36991d9f8b8cbd06970a2d53ecad82174497337c457b8b9434d9da\", \"args\": [{\"info\": \"Paging offset.\", \"name\": \"offset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Page size; less than or equal to 0 returns all.\", \"name\": \"length\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Scope, e.g. ```-3``` for only your own strategies; values are listed in the remarks.\", \"name\": \"strategyType\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Strategy type: ```-1``` all, ```0``` normal strategy, ```20``` template library, ```21``` trading plugin.\", \"name\": \"category\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Programming language, ```-1``` for all; values are listed in the remarks.\", \"name\": \"language\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Keyword matched fuzzily against strategy names, several words 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. Applies only to your own strategies.\", \"name\": \"groupId\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Sort field: ```name```, ```last_modified``` or ```date```; append ``` asc``` for ascending (descending by default); an empty string is the default order.\", \"name\": \"orderBy\", \"required\": false, \"type\": \"string\"}], \"attrs\": [{\"info\": \"Total number of matching strategies.\", \"name\": \"all\", \"type\": \"number\"}, {\"info\": \"Array of strategies.\", \"name\": \"strategies\", \"type\": \"array\"}, {\"info\": \"Strategy ID, the ```strategy``` of a robot configuration.\", \"name\": \"strategies[].id\", \"type\": \"number\"}, {\"info\": \"Strategy type, same values as the ```category``` argument.\", \"name\": \"strategies[].category\", \"type\": \"number\"}, {\"info\": \"Programming language, same values as the ```language``` argument.\", \"name\": \"strategies[].language\", \"type\": \"number\"}], \"desc\": [\"Queries strategies by scope, type, language, keyword and other conditions.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('GetStrategyList', 0, 10, -3, -1, -1, '') # your first 10 strategies\\nr = api('GetStrategyList', strategyType=-3, language=7) # all your Rust strategies\\nfor s in r['data']['result']['strategies']:\\n print(s['id'], s['name'])\", \"lang\": \"python\"}], \"value\": \"Get your first 10 strategies with positional arguments, or all your Rust strategies with named arguments.\"}], \"isChildren\": true, \"remarks\": [\"There is no ```needArgs``` parameter: passing an extra argument after ```category``` as old documentation did shifts the following arguments. Pass the arguments in the order above, or by name.\", \"Positional calls accept only 0, 6, 7 or 8 arguments. With no arguments (```args``` is ```[]```) the server fills in ```(-1, -1, -1, -1, 1, \\\"\\\")```, so ```language``` is ```1``` and only Python strategies are returned; to get all languages pass ```language``` as ```-1```, or pass arguments by name (then ```language``` defaults to ```-1```).\", \"### Parameter values\\n\\n```strategyType``` (scope):\\n\\n| Value | Meaning |\\n| - | - |\\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 |\\n\\n```category``` (strategy type): ```-1``` all, ```0``` normal strategy, ```20``` template library, ```21``` trading plugin.\\n\\n```language``` (programming language):\\n\\n| Value | Meaning |\\n| - | - |\\n| ```-1``` | All languages |\\n| ```0``` | JavaScript |\\n| ```1``` | Python |\\n| ```3``` | A discontinued strategy type that appears only in existing strategies |\\n| ```4``` | My language |\\n| ```5``` | PINE |\\n| ```6``` | Workflow |\\n| ```7``` | Rust |\", \"### Example response\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 123,\\n \\\"strategies\\\": [{\\n \\\"category\\\": 0,\\n \\\"date\\\": \\\"2024-11-10 20:40:04\\\",\\n \\\"description\\\": \\\"\\\",\\n \\\"forked\\\": 0,\\n \\\"hits\\\": 0,\\n \\\"id\\\": 123,\\n \\\"is_buy\\\": false,\\n \\\"is_owner\\\": false,\\n \\\"language\\\": 0,\\n \\\"last_modified\\\": \\\"2024-11-11 17:23:52\\\",\\n \\\"name\\\": \\\"HedgeGridStrategy\\\",\\n \\\"profile\\\": {\\n \\\"avatar\\\": \\\"...\\\",\\n \\\"nickname\\\": \\\"abc\\\",\\n \\\"uid\\\": \\\"4ed225440db1eda23fe05ed10184113e\\\"\\n },\\n \\\"public\\\": 0,\\n \\\"tags\\\": \\\"\\\",\\n \\\"uid\\\": \\\"4ed225440db1eda23fe05ed10184113e\\\",\\n \\\"username\\\": \\\"abc\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"On success ```data.result``` holds the strategy count ```all``` and the strategy array ```strategies```; fields are in the attributes table below.\", \"type\": \"object\"}], \"title\": \"GetStrategyList\"}, {\"_src_hash\": \"285e67aae5f09f50e7ee0b334ebd7bab82044238493e5a5c9c1596f312432366\", \"attrs\": [{\"info\": \"Robot group ID, the ```group``` of a robot configuration.\", \"name\": \"items[].id\", \"type\": \"number\"}, {\"info\": \"Robot group name.\", \"name\": \"items[].name\", \"type\": \"string\"}], \"desc\": [\"Gets the robot groups of the account; the \\\"Default\\\" group is not listed.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('GetRobotGroupList')\\nfor g in r['data']['result']['items']:\\n print(g['id'], g['name'])\", \"lang\": \"python\"}], \"value\": \"List the robot groups.\"}], \"isChildren\": true, \"remarks\": [\"### Example response\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"items\\\": [{\\n \\\"id\\\": 3417,\\n \\\"name\\\": \\\"test\\\"\\n }, {\\n \\\"id\\\": 3608,\\n \\\"name\\\": \\\"demo\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"On success ```data.result.items``` is the array of groups; it contains only groups you created, not the \\\"Default\\\" group.\", \"type\": \"object\"}], \"title\": \"GetRobotGroupList\"}, {\"_src_hash\": \"62dc5f439ca7c9c9abf15167d40b1bc24acabb7d9a493f261b06b2d67636b216\", \"args\": [{\"info\": \"Paging offset, 0 by default.\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Page size; less than or equal to 0 returns all (default).\", \"name\": \"length\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Filter by robot status code, see {@extended-api-interface/live-trading-status-codes Live Trading Status Codes}; ```-1``` returns all robots (default), ```-2``` all robots sorted by start time.\", \"name\": \"customStatus\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Filter by the robot's custom label (```appid``` in ```settings``` at creation); an empty string means no filter.\", \"name\": \"appId\", \"required\": false, \"type\": \"string\"}, {\"info\": \"Keyword matched fuzzily against robot names; an empty string means no filter.\", \"name\": \"kw\", \"required\": false, \"type\": \"string\"}, {\"info\": \"Robot 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``` or ```strategy_name```; append ``` asc``` for ascending (descending by default); an empty string is the default order.\", \"name\": \"orderBy\", \"required\": false, \"type\": \"string\"}, {\"info\": \"When greater than 0, only robots of this strategy are returned; 0 (no filter) by default.\", \"name\": \"strategyId\", \"required\": false, \"type\": \"number\"}], \"attrs\": [{\"info\": \"Total number of matching robots.\", \"name\": \"all\", \"type\": \"number\"}, {\"info\": \"Array of robots.\", \"name\": \"robots\", \"type\": \"array\"}, {\"info\": \"Robot ID.\", \"name\": \"robots[].id\", \"type\": \"number\"}, {\"info\": \"Robot status code, see {@extended-api-interface/live-trading-status-codes Live Trading Status Codes}.\", \"name\": \"robots[].status\", \"type\": \"number\"}, {\"info\": \"Robot group ID; robots in the default group have no such field.\", \"name\": \"robots[].group_id\", \"type\": \"number\"}], \"desc\": [\"Gets the robots of the account, optionally filtered by status, label, name, group or strategy; all arguments can be omitted.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('GetRobotList') # all robots\\n# a single string is taken as the label: all robots labeled member2\\nr = api('GetRobotList', 'member2')\\n# positional: up to 100 robots labeled member2, starting at offset 0\\nr = api('GetRobotList', 0, 100, -1, 'member2', '')\\nr = api('GetRobotList', appId='member2', length=100) # by name, same as above\\nfor robot in r['data']['result']['robots']:\\n print(robot['id'], robot['name'], robot['status'])\", \"lang\": \"python\"}], \"value\": \"Get all robots, filter by label, and pass arguments by position or by name.\"}], \"isChildren\": true, \"remarks\": [\"### Example response\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 1,\\n \\\"concurrent\\\": 0,\\n \\\"robots\\\": [{\\n \\\"charge_time\\\": 1731654846,\\n \\\"date\\\": \\\"2024-11-12 14:05:29\\\",\\n \\\"end_time\\\": \\\"2024-11-15 14:56:32\\\",\\n \\\"fixed_id\\\": 4509153,\\n \\\"id\\\": 591026,\\n \\\"is_sandbox\\\": 0,\\n \\\"name\\\": \\\"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```\"], \"returns\": [{\"info\": \"On success ```data.result``` holds the robot count ```all``` and the robot array ```robots```; fields are in the attributes table below.\", \"type\": \"object\"}], \"title\": \"GetRobotList\"}, {\"_src_hash\": \"71ee9e21871925310db591952d3cb09025842f9cd181e25ace243e19e94b512c\", \"args\": [{\"info\": \"Robot ID; see ```GetRobotList```.\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}], \"attrs\": [{\"info\": \"Robot status code, see {@extended-api-interface/live-trading-status-codes Live Trading Status Codes}.\", \"name\": \"robot.status\", \"type\": \"number\"}, {\"info\": \"Robot name.\", \"name\": \"robot.name\", \"type\": \"string\"}, {\"info\": \"Creation date.\", \"name\": \"robot.date\", \"type\": \"string\"}, {\"info\": \"Next billing time (Unix timestamp in seconds), i.e. the end of the period already paid for.\", \"name\": \"robot.charge_time\", \"type\": \"number\"}, {\"info\": \"Total billed running time in seconds.\", \"name\": \"robot.charged\", \"type\": \"number\"}, {\"info\": \"Total amount charged, in USD, as an integer scaled by 1e8; 5375000000 in the example is 53.75 USD.\", \"name\": \"robot.consumed\", \"type\": \"number\"}, {\"info\": \"Docker ID.\", \"name\": \"robot.node_id\", \"type\": \"number\"}, {\"info\": \"Docker ID set in the robot configuration; ```-1``` when assigned automatically.\", \"name\": \"robot.fixed_id\", \"type\": \"number\"}, {\"info\": \"Whether you may manage the robot.\", \"name\": \"robot.is_manager\", \"type\": \"bool\"}, {\"info\": \"Whether it is a demo (sandbox) robot.\", \"name\": \"robot.is_sandbox\", \"type\": \"number\"}, {\"info\": \"Exchange objects of the robot: keys are ```pid```, values are exchange IDs (```eid```), e.g. ```{\\\"123\\\": \\\"Futures_OKX\\\"}```.\", \"name\": \"robot.pexchanges\", \"type\": \"object\"}, {\"info\": \"Labels of the robot's exchange objects, keyed by ```pid```.\", \"name\": \"robot.plabels\", \"type\": \"object\"}, {\"info\": \"Default K-line period, exchange objects and trading pairs (JSON text); format in the remarks.\", \"name\": \"robot.strategy_exchange_pairs\", \"type\": \"string\"}, {\"info\": \"Robot profit.\", \"name\": \"robot.profit\", \"type\": \"number\"}, {\"info\": \"Whether the robot is public.\", \"name\": \"robot.public\", \"type\": \"number\"}, {\"info\": \"Last active time (millisecond timestamp).\", \"name\": \"robot.refresh\", \"type\": \"number\"}, {\"info\": \"Whether the offline alert is on.\", \"name\": \"robot.wd\", \"type\": \"number\"}], \"desc\": [\"Gets the details of one robot of the account, including its status, billing, exchange configuration and strategy arguments.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('GetRobotDetail', 123)\\nrobot = r['data']['result']['robot']\\nprint(robot['status'], robot['pexchanges'], robot['strategy_exchange_pairs'])\", \"lang\": \"python\"}], \"value\": \"Query the status and exchange configuration of robot 123.\"}], \"isChildren\": true, \"remarks\": [\"```strategy_exchange_pairs``` is the text of a JSON array, e.g. ```\\\"[60,[44314,42960,15445,14703],[\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\"]]\\\"```:\\n\\n- ```60```: the default K-line period of the robot in seconds (1 minute here).\\n- ```[44314,42960,15445,14703]```: the ```pid``` of the robot's exchange objects, in the order they were added.\\n- ```[\\\"BTC_USDT\\\",\\\"BTC_USDT\\\",\\\"ETH_USDT\\\",\\\"ETH_USDT\\\"]```: the trading pair of each exchange object, matching the ```pid``` list in order.\", \"### Example response\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"robot\\\": {\\n \\\"charge_time\\\": 1732246539,\\n \\\"charged\\\": 5850000,\\n \\\"consumed\\\": 5375000000,\\n \\\"date\\\": \\\"2018-12-28 14:34:51\\\",\\n \\\"favorite\\\": {\\n \\\"added\\\": false,\\n \\\"type\\\": \\\"R\\\"\\n },\\n \\\"fixed_id\\\": 123,\\n \\\"hits\\\": 1,\\n \\\"id\\\": 123,\\n \\\"is_deleted\\\": 0,\\n \\\"is_manager\\\": true,\\n \\\"is_sandbox\\\": 0,\\n \\\"name\\\": \\\"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```\"], \"returns\": [{\"info\": \"On success ```data.result.robot``` is the robot information; fields are in the attributes table below.\", \"type\": \"object\"}], \"title\": \"GetRobotDetail\"}, {\"_src_hash\": \"4eed8f7088652bbfb8158bee95dc8cdb3c89856a2794c3883da7ecb0ede25d27\", \"args\": [{\"info\": \"Robot ID; see ```GetRobotList```.\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Minimum ID of strategy log entries.\", \"name\": \"logMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Maximum ID of strategy log entries.\", \"name\": \"logMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Number of records to skip within the range given by ```logMinId``` and ```logMaxId```.\", \"name\": \"logOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Number of records to return from the starting position.\", \"name\": \"logLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Minimum ID of profit log entries.\", \"name\": \"profitMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Maximum ID of profit log entries.\", \"name\": \"profitMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Number of records to skip.\", \"name\": \"profitOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Number of records to return.\", \"name\": \"profitLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Minimum ID of chart log entries.\", \"name\": \"chartMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Maximum ID of chart log entries.\", \"name\": \"chartMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Number of records to skip.\", \"name\": \"chartOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Number of records to return.\", \"name\": \"chartLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Base ID for querying updates.\", \"name\": \"chartUpdateBaseId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Update timestamp; only newer records are returned.\", \"name\": \"chartUpdateDate\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Whether to return status bar data: ```0``` does not; greater than 0 returns it in ```summary``` (the value itself has no effect; at most 2MB).\", \"name\": \"summaryLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Return only logs of this exchange object (by label); an empty string means no filter.\", \"name\": \"logExchange\", \"required\": false, \"type\": \"string\"}, {\"info\": \"Return only logs whose content contains this keyword; an empty string means no filter.\", \"name\": \"logKeyword\", \"required\": false, \"type\": \"string\"}, {\"info\": \"Return only these log types, comma-separated 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\"}], \"attrs\": [{\"info\": \"Three objects: the query results of the strategy log, profit log and chart log tables of the robot database, in that order; the ```Arr``` of each holds the records, formatted as described in the remarks.\", \"name\": \"logs\", \"type\": \"array\"}, {\"info\": \"Status bar data of the robot (returned when ```summaryLimit``` is greater than 0).\", \"name\": \"summary\", \"type\": \"string\"}, {\"info\": \"Robot status code, see {@extended-api-interface/live-trading-status-codes Live Trading Status Codes}.\", \"name\": \"status\", \"type\": \"number\"}], \"desc\": [\"Gets the strategy log, profit log, chart data and status bar data of one robot of the account.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('GetRobotLogs', robotId=123, logLimit=10, summaryLimit=1)\\nresult = r['data']['result']\\nfor row in result['logs'][0]['Arr']:\\n print(row)\\nprint(result['summary']) # status bar data\", \"lang\": \"python\"}], \"value\": \"Query the latest 10 strategy log entries and the status bar of robot 123, passing arguments by name.\"}], \"isChildren\": true, \"remarks\": [\"With this many parameters, passing them by name is recommended (missing ones take their defaults); positional calls take 15 to 19 arguments (with 15 the status bar is not queried). The three filters ```logExchange```, ```logKeyword``` and ```logTypes``` work only on new dockers; old dockers ignore them and return all logs.\", \"### logs[0]: strategy log\\n\\nEach entry of ```logs[0].Arr``` is an array of: log ID (```id```), log type (```logType```), label of the exchange object (```platformId```), order ID (```orderId```), price (```price```), amount (```amount```), extra message of the log (```extra```), timestamp (```date```), contract code (```contractType```), direction (```direction```). For example:\\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 too many positions, long: 2\\\", 1526954372410, \\\"\\\", \\\"\\\"]\\n]\\n```\\n\\nValues of ```logType```:\\n\\n| logType | Name | Meaning |\\n| - | - | - |\\n| 0 | BUY | Buy order |\\n| 1 | SALE | Sell order |\\n| 2 | RETRACT | Order cancelled |\\n| 3 | ERROR | Error |\\n| 4 | PROFIT | Profit |\\n| 5 | MESSAGE | Log message |\\n| 6 | RESTART | Restart |\", \"### logs[1]: profit log\\n\\nThe same as the profit entries of the strategy log; each entry is log ID, profit value, timestamp. In ```[202, 2515.44, 1575896700315]```, ```202``` is the log ID, ```2515.44``` the profit and ```1575896700315``` the timestamp:\\n\\n```plaintext\\n\\\"Arr\\\": [\\n [202, 2515.44, 1575896700315],\\n [201, 1415.44, 1575896341568]\\n]\\n```\", \"### logs[2]: chart log\\n\\nEach entry is log ID, chart series index, data (JSON text). In ```[23637, 0, \\\"{\\\\\\\"close\\\\\\\":648, ...}\\\"]```, ```23637``` is the log ID, ```0``` the series index, and the JSON text is one K-line on the chart:\\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```\", \"### Example response\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"chart\\\": \\\"\\\",\\n \\\"chartTime\\\": 0,\\n \\\"logs\\\": [{\\n \\\"Total\\\": 20,\\n \\\"Max\\\": 20,\\n \\\"Min\\\": 1,\\n \\\"Arr\\\": []\\n }, {\\n \\\"Total\\\": 0,\\n \\\"Max\\\": 0,\\n \\\"Min\\\": 0,\\n \\\"Arr\\\": []\\n }, {\\n \\\"Total\\\": 0,\\n \\\"Max\\\": 0,\\n \\\"Min\\\": 0,\\n \\\"Arr\\\": []\\n }],\\n \\\"node_id\\\": 123,\\n \\\"online\\\": true,\\n \\\"refresh\\\": 1732201544000,\\n \\\"status\\\": 4,\\n \\\"summary\\\": \\\"...\\\",\\n \\\"updateTime\\\": 1732201532636,\\n \\\"wd\\\": 0\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"On success ```data.result``` holds the logs ```logs```, the status bar data ```summary``` and more; fields are in the attributes table below.\", \"type\": \"object\"}], \"title\": \"GetRobotLogs\"}, {\"_src_hash\": \"5e0633a576409daf6dfd139304f0ef6a13ac415133f80aadd045fcb508a5fa77\", \"args\": [{\"info\": \"Robot configuration; fields are described under \\\"Robot configuration (settings)\\\" in {@extended-api-interface/extended-api-interface-details Extended API Interface Details}.\", \"name\": \"settings\", \"required\": true, \"type\": \"object\"}], \"desc\": [\"Creates a robot in the account and starts it; like creating a robot on the website, this charges fees and the robot trades for real.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nsettings = {\\n \\\"name\\\": \\\"test\\\",\\n \\\"strategy\\\": 123,\\n \\\"args\\\": [],\\n \\\"exchanges\\\": [\\n {\\\"pid\\\": 123, \\\"pair\\\": \\\"SOL_USDT\\\"}\\n ],\\n \\\"period\\\": 60,\\n \\\"node\\\": 123,\\n \\\"group\\\": 123,\\n \\\"appid\\\": \\\"test\\\"\\n}\\nr = api('NewRobot', settings)\\nprint(r['data']['result']) # output: 591988 (ID of the new robot)\", \"lang\": \"python\"}], \"value\": \"Create and start a robot with an added exchange account (```pid```).\"}], \"isChildren\": true, \"remarks\": [\"When created through the extended API, the call returns after the start-up has run. If start-up fails (e.g. the strategy does not compile), the ID of the new robot is still returned and the robot is in the \\\"strategy error\\\" state (status code ```5```), so check its status with ```GetRobotDetail``` after creating it.\", \"A negative result means no robot was created; see \\\"Return values of failed starts\\\" in {@extended-api-interface/live-trading-status-codes Live Trading Status Codes}, e.g. ```-2``` no docker found, ```-5``` insufficient balance. When the account exceeds the number of robots it may run, an error with ```code``` 6 is returned.\", \"When an exchange configuration is passed directly with ```eid```, the platform does not store the keys in ```meta```, so every later restart of the robot with ```RestartRobot``` must pass ```settings``` again.\"], \"returns\": [{\"info\": \"```data.result```: the ID of the new robot on success; ```0``` when ```args``` in ```settings``` is not an array; a negative number when no robot was created, see the remarks.\", \"type\": \"number\"}], \"title\": \"NewRobot\"}, {\"_src_hash\": \"451509ab27d4fa49046499465e423944585eedc8b6848fad76758a31a811c34e\", \"args\": [{\"info\": \"Robot ID; see ```GetRobotList```.\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"New robot configuration; when given it replaces the whole configuration before starting, see the remarks. Fields are described under \\\"Robot configuration (settings)\\\" in {@extended-api-interface/extended-api-interface-details Extended API Interface Details}.\", \"name\": \"settings\", \"required\": false, \"type\": \"object\"}], \"desc\": [\"Starts (restarts) a robot of the account, optionally replacing its configuration; starting charges fees.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('RestartRobot', 123)\\nprint(r['data']['result']) # output: 0 (preparing; the start-up has run)\", \"lang\": \"python\"}], \"value\": \"Start robot 123 with its current configuration.\"}], \"isChildren\": true, \"remarks\": [\"A robot created on the website with added exchange accounts (```pid```) can be started with just ```robotId```, using its current configuration. A robot whose exchange configurations were passed directly with ```eid``` (usually created through the extended API) has no stored keys, so ```settings``` must be passed on every restart.\", \"When ```settings``` is given, it **replaces** the robot's whole configuration (name, arguments, exchanges, K-line period, docker) before the start; the strategy cannot be changed. Fields left out do not keep their old values: ```name``` becomes an empty string, ```args``` becomes ```[]``` (all arguments back to their defaults), leaving out ```exchanges``` deletes all of the robot's exchange configurations, ```period``` becomes 60 seconds and ```node``` becomes automatic; only ```group``` keeps the old group when omitted or ```0```. So always pass a complete configuration; it is best to get the current one with ```GetRobotDetail``` and modify it.\", \"Passing ```settings``` while the robot is preparing, running or stopping returns an error with ```code``` 6 (```robot is running```); without ```settings``` the robot is not restarted and its current status code (```0```, ```1``` or ```2```) is returned.\", \"A negative result means the start failed; see \\\"Return values of failed starts\\\" in {@extended-api-interface/live-trading-status-codes Live Trading Status Codes}. Whether the robot is then running, or in \\\"strategy error\\\" because it failed to compile, must be checked with ```GetRobotDetail```.\"], \"returns\": [{\"info\": \"```data.result```: normally ```0``` (preparing), meaning the start-up has run; whether the start succeeded must be checked with ```GetRobotDetail```. Other return values are in the remarks.\", \"type\": \"number\"}], \"title\": \"RestartRobot\"}, {\"_src_hash\": \"e88e06b753f17f4965e94b891682ba65d1fdd7da79c1b728a329dc056c8bc060\", \"args\": [{\"info\": \"Robot ID; see ```GetRobotList```.\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"Stops a robot of the account; stopping does not close positions.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('StopRobot', 123)\\nprint(r['data']['result']) # output: 2 (stopping)\", \"lang\": \"python\"}], \"value\": \"Stop robot 123.\"}], \"isChildren\": true, \"remarks\": [\"While the robot is starting or stopping (```robot is busy```), or when its docker is offline (```docker not found```), an error with ```code``` 6 is returned.\"], \"returns\": [{\"info\": \"```data.result``` is the robot status code: ```2``` (stopping) means the stop command was sent to the docker; ```4``` (stopped) means the robot's docker has been deleted, so the robot was set to stopped directly; ```3```, ```4``` or ```5``` may also mean the robot had already ended.\", \"type\": \"number\"}], \"title\": \"StopRobot\"}, {\"_src_hash\": \"73ec9c7670df4cc0594722ec8dbe687ffb79dfb95070f14f442db8031a1eb469\", \"args\": [{\"info\": \"ID of the robot that receives the command; see ```GetRobotList```.\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The interactive command; the strategy reads it with ```GetCommand()```.\", \"name\": \"cmd\", \"required\": true, \"type\": \"string\"}], \"desc\": [\"Sends an interactive command to a running robot of the account; the strategy receives it with {@fun/Global/GetCommand GetCommand}.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('CommandRobot', 123, 'test command')\\nprint(r['data']['result']) # output: True\", \"lang\": \"python\"}], \"value\": \"Send the command ```test command``` to running robot 123; its strategy receives it with ```GetCommand()``` and logs it (strategy code in the remarks).\"}], \"isChildren\": true, \"remarks\": [\"A strategy that receives the command:\\n\\n```javascript\\n// strategy run by robot 123: print each interactive command it receives\\nfunction main() {\\n while (true) {\\n var cmd = GetCommand()\\n if (cmd) {\\n Log(cmd)\\n }\\n Sleep(2000)\\n }\\n}\\n```\", \"To call ```CommandRobot``` from a webhook that accepts only one URL, such as TradingView, see {@extended-api-interface/authentication-methods/direct-verification Direct Verification}.\"], \"returns\": [{\"info\": \"```data.result``` tells whether the command was sent; it is ```false``` when the robot is not running.\", \"type\": \"bool\"}], \"title\": \"CommandRobot\"}, {\"_src_hash\": \"f8ff583140899bbf39bad0db09180e8a77273cb24e6049807a528957cd6a1305\", \"args\": [{\"info\": \"Robot ID; see ```GetRobotList```.\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Whether to delete the robot's log data on the docker as well. Defaults to ```true``` when passed by name, and to ```false``` when only ```[robotId]``` is passed by position. Passing it explicitly is recommended.\", \"name\": \"removeLog\", \"required\": false, \"type\": \"bool\"}], \"desc\": [\"Deletes a robot of the account; a running robot must be stopped first, and deletion cannot be undone.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nr = api('DeleteRobot', robotId=123, removeLog=True)\\nprint(r['data']['result']) # output: 0 (deleted)\", \"lang\": \"python\"}], \"value\": \"Delete the stopped robot 123 together with its log data on the docker.\"}], \"isChildren\": true, \"returns\": [{\"info\": \"```data.result```: ```0``` deleted; ```-1``` not deleted (the robot does not exist, or is running, starting or stopping); ```-2``` the robot was deleted but its docker could not be reached, so the log data was not deleted and must be removed by hand from ```logs/storage//``` in the docker directory (e.g. ```123.db3```).\", \"type\": \"number\"}], \"title\": \"DeleteRobot\"}, {\"_src_hash\": \"69d02a257e6177631bcc1bffda50bcb26f7b6cf674dfa04f6868887a20669a72\", \"args\": [{\"info\": \"Run configuration; fields are in the attributes table below.\", \"name\": \"settings\", \"required\": true, \"type\": \"object\"}], \"attrs\": [{\"info\": \"The code to run; its entry is ```main()```, whose return value is the result.\", \"name\": \"settings.source\", \"type\": \"string\"}, {\"info\": \"Without ```source```, run the account's strategy with this ID (e.g. a trading plugin).\", \"name\": \"settings.strategy\", \"type\": \"number\"}, {\"info\": \"ID of the docker that runs the code; omitted or ```-1``` chooses one automatically.\", \"name\": \"settings.node\", \"type\": \"number\"}, {\"info\": \"Exchange object configuration, written as in \\\"Robot configuration (settings)\\\" in {@extended-api-interface/extended-api-interface-details Extended API Interface Details}.\", \"name\": \"settings.exchanges\", \"type\": \"array\"}], \"desc\": [\"Runs a piece of JavaScript code on a docker and returns the result, without creating a robot or charging fees; one run lasts at most 5 minutes, and the code can place real orders.\"], \"examples\": [{\"examples\": [{\"code\": \"# api() is the function in the Python example on the signature authentication page\\nimport json\\n\\nsettings = {\\n \\\"source\\\": \\\"function main() {Log(\\\\\\\"Hello FMZ\\\\\\\")}\\\",\\n \\\"node\\\": 123,\\n \\\"period\\\": 60,\\n \\\"exchanges\\\": [{\\\"pid\\\": 123, \\\"pair\\\": \\\"SOL_USDT\\\"}]\\n}\\nr = api('PluginRun', settings)\\nout = json.loads(r['data']['result'])\\nprint(out['logs'], out['result'])\", \"lang\": \"python\"}], \"value\": \"Run code on docker 123 and get its logs and return value.\"}], \"isChildren\": true, \"remarks\": [\"It uses the same execution mechanism as the \\\"Debugging Tool\\\" of the development tools and trading terminal plugins; see {@platform-basics/trading-terminal/plugin-principle-and-development Plugin Principle and Development}.\", \"```exchanges``` can also pass an exchange configuration directly instead of referencing an exchange account on the platform, e.g. ```{\\\"eid\\\": \\\"Binance\\\", \\\"pair\\\": \\\"ETH_BTC\\\", \\\"meta\\\": {\\\"AccessKey\\\": \\\"...\\\", \\\"SecretKey\\\": \\\"...\\\"}}```; the field names of ```meta``` are given by the ```meta``` returned by ```GetExchangeList```. Usually only one exchange object is set in ```exchanges``` (the debugging tool page supports only one); setting two raises no error, but accessing the second exchange object in the code does.\", \"### Example response\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": \\\"{\\\\\\\"logs\\\\\\\": [...], \\\\\\\"result\\\\\\\": \\\\\\\"\\\\\\\"}\\\",\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\nParsed, ```result``` is:\\n\\n```json\\n{\\n \\\"logs\\\": [{\\n \\\"PlatformId\\\": \\\"\\\", \\\"OrderId\\\": \\\"0\\\", \\\"LogType\\\": 5, \\\"Price\\\": 0, \\\"Amount\\\": 0,\\n \\\"Extra\\\": \\\"Hello FMZ\\\", \\\"Currency\\\": \\\"\\\", \\\"Instrument\\\": \\\"\\\", \\\"Direction\\\": \\\"\\\",\\n \\\"Time\\\": 1732267473108\\n }],\\n \\\"result\\\": \\\"\\\"\\n}\\n```\"], \"returns\": [{\"info\": \"```data.result``` is JSON text: ```logs``` holds the lines written by ```Log()``` in the code, and ```result``` is the JSON text of the return value of ```main()```.\", \"type\": \"string\"}], \"title\": \"PluginRun\"}, {\"_src_hash\": \"962be2513d78ecb4c0cb2f476000ac0429f1f0cdc5b3c22bd9124e0db9264434\", \"args\": [{\"info\": \"ID of the robot that receives the message (URL parameter). The robot must be running and already subscribed to ```channel```.\", \"name\": \"robot\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Channel name (URL parameter); a 32-character random string (a UUID without hyphens) is recommended. It must not be all digits (that is taken as a robot ID, i.e. the robot's own channel); names shorter than 10 characters are not delivered.\", \"name\": \"channel\", \"required\": true, \"type\": \"string\"}, {\"info\": \"Message content. For ```POST``` requests it is the whole request body, any text such as JSON or plain text; otherwise it is the URL parameter ```message```.\", \"name\": \"message\", \"required\": false, \"type\": \"string\"}], \"attrs\": [{\"info\": \"```ok``` on success.\", \"name\": \"data.status\", \"type\": \"string\"}, {\"info\": \"Echo of the request's ```robot``` parameter.\", \"name\": \"data.robot\", \"type\": \"number\"}, {\"info\": \"Echo of the request's ```channel``` parameter.\", \"name\": \"data.channel\", \"type\": \"string\"}, {\"info\": \"The message pushed.\", \"name\": \"data.message\", \"type\": \"string\"}, {\"info\": \"Number of dockers that received the message.\", \"name\": \"data.affected\", \"type\": \"number\"}], \"desc\": [\"Pushes a message to a channel subscribed by a running robot, so that systems outside the platform (TradingView webhook alerts, your own trading system, monitoring scripts and so on) can send data to the robot. The robot reads it with {@fun/Storage/GetChannelData GetChannelData}; for how channels work see {@advanced-topics/communication-between-live-trading-strategies Communication Between Live Trading Strategies}.\", \"Unlike the other methods, ```pub``` **needs no API key and no signature**: the request URL is ```https://www.fmz.com/api/v1?method=pub&robot={robotId}&channel={channel}``` and the message goes in the request body (```POST```). Anyone who knows the robot ID and the channel name can push, so use a hard-to-guess random string as the channel name, and have the strategy validate what it receives as untrusted input.\"], \"examples\": [{\"examples\": [{\"code\": \"// receiving robot (assume its ID is 123456)\\nvar CHANNEL = \\\"6BC42A119B5DBFA2188A8279DA3B5C30\\\"\\n\\nfunction main() {\\n var lastId = null\\n while (true) {\\n var msg = GetChannelData(CHANNEL) // the first call subscribes and returns null\\n if (typeof msg == \\\"string\\\") {\\n var obj = null\\n try {\\n obj = JSON.parse(msg) // parse again when the body is JSON text\\n } catch (e) {\\n Log(\\\"non-JSON message:\\\", msg)\\n }\\n // the channel keeps only the latest message; use id to spot new ones\\n if (obj && obj.id != lastId) {\\n lastId = obj.id\\n Log(\\\"external message received:\\\", obj)\\n }\\n }\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import json\\n\\nCHANNEL = \\\"6BC42A119B5DBFA2188A8279DA3B5C30\\\"\\n\\ndef main():\\n lastId = None\\n while True:\\n msg = GetChannelData(CHANNEL) # the first call subscribes and returns None\\n if isinstance(msg, str):\\n try:\\n obj = json.loads(msg) # parse again when the body is JSON text\\n except ValueError:\\n obj = None\\n Log(\\\"non-JSON message:\\\", msg)\\n if isinstance(obj, dict) and obj.get(\\\"id\\\") != lastId:\\n lastId = obj.get(\\\"id\\\")\\n Log(\\\"external message received:\\\", obj)\\n Sleep(1000)\", \"lang\": \"python\"}], \"value\": \"Receiving strategy: subscribe to the channel, parse the JSON messages it receives, and use ```id``` to tell new messages from old ones.\"}], \"isChildren\": true, \"remarks\": [\"### Delivery rules\\n\\n- Subscribe first, then push: the robot's first ```GetChannelData(channel)``` call subscribes to the channel (and returns a null value); the subscription is reported with the docker's heartbeat, so the external system can push successfully only after a short while. Requests fail while no robot subscribes.\\n- The message is delivered to the docker of the ```robot``` robot, and every robot on that docker subscribed to the same channel receives it; robots on other dockers do not.\\n- A channel keeps only the latest message, with no queue: ```GetChannelData()``` returns the most recent one each time, and reading does not clear it. To tell new messages from old ones, include an increasing number or a timestamp in the message.\\n- Each robot can subscribe to at most 10 channels (other robots' channels included); beyond that ```GetChannelData()``` returns a null value and logs the error ```channel subscriber exceed limit```.\\n- The robot receives a **string** (the raw request body). When the body is JSON text, the strategy has to parse it again.\", \"### Example push request\\n\\nAn external system pushes a message:\\n\\n```bash\\ncurl -X POST \\\\\\n \\\"https://www.fmz.com/api/v1?method=pub&robot=123456&channel=6BC42A119B5DBFA2188A8279DA3B5C30\\\" \\\\\\n -d '{\\\"id\\\": 1, \\\"action\\\": \\\"buy\\\", \\\"symbol\\\": \\\"BTC_USDT\\\"}'\\n```\\n\\nIn TradingView, put the URL above in the alert's webhook URL; the alert message becomes the request body.\", \"### Example response\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"status\\\": \\\"ok\\\",\\n \\\"robot\\\": 123456,\\n \\\"channel\\\": \\\"6BC42A119B5DBFA2188A8279DA3B5C30\\\",\\n \\\"message\\\": \\\"{\\\\\\\"id\\\\\\\": 1, \\\\\\\"action\\\\\\\": \\\\\\\"buy\\\\\\\", \\\\\\\"symbol\\\\\\\": \\\\\\\"BTC_USDT\\\\\\\"}\\\",\\n \\\"affected\\\": 1\\n }\\n}\\n```\\n\\nWhen no robot subscribes to the channel:\\n\\n```json\\n{\\n \\\"code\\\": 5,\\n \\\"error\\\": \\\"No subscribers for channel: 6BC42A119B5DBFA2188A8279DA3B5C30\\\",\\n \\\"data\\\": null\\n}\\n```\"], \"returns\": [{\"info\": \"On success ```code``` is 0 and the fields of ```data``` are in the attributes table below; when no robot subscribes to the channel (or the channel name is invalid, or ```robot``` is empty), the HTTP status is 500 and ```code``` is 5.\", \"type\": \"object\"}], \"title\": \"pub\"}], \"desc\": \"All methods are called through ```https://www.fmz.com/api/v1```; for the request format and signature see {@extended-api-interface/authentication-methods/token-authentication Token Authentication}, for the response structure and error codes see {@extended-api-interface/extended-api-interface-return-codes 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 are optional) | Description | Notes |\\n| - | - | - | - | - |\\n| Account | {@extended-api-interface/extended-api-interface-details/getaccount GetAccount} | none | Account information | Read-only |\\n| Docker | {@extended-api-interface/extended-api-interface-details/getnodelist GetNodeList} | [offset, limit] | Docker list | Read-only |\\n| Docker | {@extended-api-interface/extended-api-interface-details/deletenode DeleteNode} | nid | Delete a docker | Deletes, cannot be undone |\\n| Exchange | {@extended-api-interface/extended-api-interface-details/getexchangelist GetExchangeList} | isSummary | Exchanges supported by the platform and their settings | Read-only |\\n| Exchange | {@extended-api-interface/extended-api-interface-details/getplatformlist GetPlatformList} | [offset, limit] | Exchange accounts you added | Read-only |\\n| Strategy | {@extended-api-interface/extended-api-interface-details/getstrategylist GetStrategyList} | offset, length, strategyType, category, language, kw[, groupId, orderBy] | Strategy list | Read-only |\\n| Robot | {@extended-api-interface/extended-api-interface-details/getrobotgrouplist GetRobotGroupList} | none | Robot groups | Read-only |\\n| Robot | {@extended-api-interface/extended-api-interface-details/getrobotlist GetRobotList} | [offset, length, customStatus, appId, kw, groupId, orderBy, strategyId] | Robot list | Read-only |\\n| Robot | {@extended-api-interface/extended-api-interface-details/getrobotdetail GetRobotDetail} | robotId | Robot details | Read-only |\\n| Robot | {@extended-api-interface/extended-api-interface-details/getrobotlogs GetRobotLogs} | robotId, logMinId, …, summaryLimit[, logExchange, logKeyword, logTypes] | Logs, profit, chart and status bar data | Read-only |\\n| Robot | {@extended-api-interface/extended-api-interface-details/newrobot NewRobot} | settings | Create and start a robot | Charges fees; the robot trades for real |\\n| Robot | {@extended-api-interface/extended-api-interface-details/restartrobot RestartRobot} | robotId[, settings] | Start (restart) a robot | Charges fees; the robot trades for real |\\n| Robot | {@extended-api-interface/extended-api-interface-details/stoprobot StopRobot} | robotId | Stop a robot | Does not close positions |\\n| Robot | {@extended-api-interface/extended-api-interface-details/commandrobot CommandRobot} | robotId, cmd | Send an interactive command | The strategy may place orders on it |\\n| Robot | {@extended-api-interface/extended-api-interface-details/deleterobot DeleteRobot} | robotId[, removeLog] | Delete a robot | Deletes, cannot be undone |\\n| Debugging | {@extended-api-interface/extended-api-interface-details/pluginrun PluginRun} | settings | Run a piece of code on a docker | The code can place real orders |\\n| Channel | {@extended-api-interface/extended-api-interface-details/pub pub} | robot, channel (URL parameters); the message goes in the request body | Push a message to a channel a robot subscribed to | No API key, no signature |\\n\\nThe API key needs permission for the method, see {@extended-api-interface/create-apikey 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\\\"]```. Positional calls accept only certain numbers of arguments; any other count returns a ```Params number mismatch``` error:\\n - GetNodeList, GetPlatformList: 0 or 2.\\n - GetStrategyList: 0, 6, 7 or 8; with no arguments ```language``` is ```1``` (only Python strategies), see {@extended-api-interface/extended-api-interface-details/getstrategylist GetStrategyList}.\\n - GetRobotList: 0, 1, 3, 5, 6, 7 or 8; a single argument is taken as ```appId```.\\n - GetRobotLogs: 15 to 19 (with 15 the status bar is not queried).\\n - RestartRobot, DeleteRobot: 1 or 2; when DeleteRobot gets only ```robotId```, ```removeLog``` is ```false```.\\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### Robot configuration (settings)\\n\\nThe ```settings``` parameter of NewRobot, RestartRobot and PluginRun is a JSON object; common fields:\\n\\n| Field | Description |\\n| - | - |\\n| name | Robot name. |\\n| strategy | Strategy ID, see GetStrategyList. RestartRobot cannot change a robot'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```; 60 seconds when omitted. Pass 60 or more; see below the table. |\\n| node | ID of the docker that runs the robot, see GetNodeList; omitted or ```-1``` means automatic assignment. |\\n| group | Robot group ID, see GetRobotGroupList. |\\n| appid | Custom label; GetRobotList can filter by it. |\\n\\nA ```period``` of ```0```, ```1```, ```2```, ```3```, ```4```, ```5```, ```10``` or ```12``` is read as an old period number (1 minute, 3 minutes, 5 minutes, 15 minutes, 30 minutes, 1 hour, 1 day, 1 week respectively); for example ```1``` actually means 180 seconds.\\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 robot 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\": \"eb578f0a004f6c539c811443b83db2aabde73f07a85a1325047ec75efa5edb31\", \"desc\": \"Every response of the extended API has the JSON structure below: ```code``` tells whether the request itself succeeded, and the method's result is in ```data```.\\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 request cannot be dispatched (e.g. mismatched ```method```/```args``` counts) | 5 |\\n| The method failed while running (e.g. no permission for the robot, robot busy, too many running robots); see below | 6 |\\n| The request's source IP is not in this API KEY's IP whitelist | 7 |\\n\\nWith ```code``` 0 the method's result is in ```data.result```. When the number or types of the arguments do not match the method, ```code``` is still 0, ```data.result``` is ```null``` and ```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```\\n\\nWhen the method fails while running, ```code``` is 6, the message is in the top-level ```error``` field and ```data``` is ```null```. For example, when operating on a robot that is not yours:\\n\\n```json\\n{\\n \\\"code\\\": 6,\\n \\\"error\\\": \\\"Access Denied\\\",\\n \\\"data\\\": null\\n}\\n```\", \"title\": \"Extended API Interface Return Codes\"}, {\"_src_hash\": \"cc67faf57b126609bea0a4e63338d3a009ce31d65ad492e874ba41d06cbaeb2b\", \"desc\": \"The ```status``` field in the data returned by ```GetRobotList```, ```GetRobotDetail``` and ```GetRobotLogs``` is the robot status code, with these values.\\n\\n| Status | Code |\\n| - | - |\\n| Preparing (queued, compiling) | 0 |\\n| Running | 1 |\\n| Stopping | 2 |\\n| Exited | 3 |\\n| Stopped | 4 |\\n| Strategy error | 5 |\\n\\n### Return values when a start fails\\n\\nNegative codes never appear in the ```status``` field; they are only returned by ```NewRobot``` and ```RestartRobot``` when the start fails:\\n\\n| Meaning | Code |\\n| - | - |\\n| Strategy not usable: rental expired, neither yours nor rented, deleted, or the given version does not exist | -1 |\\n| No usable docker: the given docker is offline, or no docker is online | -2 |\\n| Failed to read the live trading or account data | -3 |\\n| The robot's status changed at the same time as the start (```RestartRobot``` only); query it again and retry | -4 |\\n| Insufficient balance | -5 |\\n| The concurrency limit of a rented strategy has been reached and the strategy has no overage price | -6 |\\n\\nErrors such as exceeding the number of robots the account may run, or having no permission for the live trading, are not reported as return values but as an error with ```code``` 6; see {@extended-api-interface/extended-api-interface-return-codes Extended API Interface Return Codes}.\", \"title\": \"Live Trading Status Codes\"}], \"desc\": \"The platform's HTTP interface (```https://www.fmz.com/api/v1```) for scripts, scheduled jobs and other programs: query the account, dockers, strategies and robots, create, restart and stop robots, send interactive commands to robots, and so on.\\n\\nTo operate the platform interactively from an AI assistant (Claude Code, Cursor, ...), prefer AI Integration (the MCP service, see {@extended-api-interface/ai-integration 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 ({@extended-api-interface/create-apikey Create ApiKey}), send requests as described in {@extended-api-interface/authentication-methods Authentication Methods}, and look up methods and parameters in {@extended-api-interface/extended-api-interface-details Extended API Interface Details}.\", \"title\": \"Extended API Interface\"}]","language","en-US","languageMode","system","sessionData",{"_375":25,"_376":25,"_377":242,"_378":242,"_379":25,"_170":25,"_380":25,"_381":25},"settings",{"_30":31,"_32":33},"zone","fmz","theme",{"_28":14,"_29":-7},"colorUpGreen","isWebApp",false,"cdnBase","","themeMode","resolvedThemeMode","appSettings",{"_150":151,"_152":153,"_154":155,"_156":157,"_158":159,"_160":161,"_162":163,"_164":165,"_166":167,"_168":169,"_170":171,"_172":173,"_174":175,"_176":177,"_178":179},"uiFooter",{"_34":35,"_36":37,"_38":39},"copyright",{"_40":149,"_42":149},"download",{"_145":146,"_147":148},"footer",{"_40":41,"_42":43},"zh_CN",[101,102,103],"en_US",[44,45,46],{"_47":84,"_49":85},{"_47":67,"_49":68},{"_47":48,"_49":50},"title","API","items",[51,52,53,54,55],{"_47":65,"_57":66},{"_47":63,"_57":64},{"_47":61,"_57":62},{"_47":59,"_57":60},{"_47":56,"_57":58},"Indicator","url","/api#indicator-functions","Blockchain","/api#blockchain","Trading api","/api#trading-api","User guide","/user-guide","Syntax guide","/syntax-guide","Product",[69,70,71,72,73],{"_47":82,"_57":83},{"_47":80,"_57":81},{"_47":78,"_57":79},{"_47":76,"_57":77},{"_47":74,"_57":75},"Tickets","/m/tickets","Platforms","/m/platforms","Node","/m/add-node","Strategy","/m/add-strategy","Robot","/m/add-robot","Forums",[86,87,88,89,90],{"_47":99,"_57":100},{"_47":97,"_57":98},{"_47":95,"_57":96},{"_47":93,"_57":94},{"_47":91,"_57":92},"About Us","/about-us","Web3","/bbs-topic/10032","MyLanguage","/bbs-topic/9480","FAQ Summary","/bbs-topic/9158","PINE Language","/bbs-topic/9637",{"_47":131,"_49":132},{"_47":119,"_49":120},{"_47":104,"_49":105},"API文档",[106,107,108,109,110],{"_47":118,"_57":66},{"_47":117,"_57":64},{"_47":115,"_57":116},{"_47":113,"_57":114},{"_47":111,"_57":112},"指标函数","/api#指标函数","区块链","/api#区块链","交易api","/api#交易api","用户指南","语法手册","产品功能",[121,122,123,124,125],{"_47":130,"_57":83},{"_47":129,"_57":81},{"_47":128,"_57":79},{"_47":127,"_57":77},{"_47":126,"_57":75},"工单","交易所","部署托管者","新建策略","创建实盘","社区",[133,134,135,136,137],{"_47":143,"_57":144},{"_47":117,"_57":64},{"_47":141,"_57":142},{"_47":139,"_57":140},{"_47":138,"_57":92},"关于我们","托管者安装和升级","/bbs-topic/2848","Python入门指南","/bbs-topic/4388","回测系统","/api#回测系统","android","/dist/fmz.apk","ios","itms-apps://itunes.apple.com/WebObjects/MZStore.woa/wa/viewSoftware?id=1572932684","© 2015 - ∞ INVENTOR PTE LTD (SG)","banner",[357,358,359,360,361],"nav",[324,325,326,327,328,329,330,331],"ad",[320],"ad1",[308,309,310],"embedx",[289,290],"payments",[244,245,246,247,248],"strategy",[222,223,224,225,226,227],"sso",[204,205,206],"update",{"_145":186,"_147":187,"_188":189},"redirect",{"_184":185},"openai",true,"ui",{"_180":171,"_181":171,"_182":183},"datadata_snapshot","https://www.datadata.com/web/resources/{{uuid}}/screenshot.png","chart","https://www.fmz.com/app/chart","timeout",15000,"show_prop_strategies","aiguide","datadata","https://www.datadata.com","/strategy/268542","/strategy/520271",{"_190":191,"_197":198,"_192":202,"_194":203,"_188":195,"_199":200,"_34":201},{"_192":196,"_190":191,"_197":198,"_194":148,"_199":200,"_34":201},"web",{"_190":191,"_192":193,"_194":195},"version","v2.2.36","paymethod","balance,voucher","link","https://www.fmz.com/mobile","","min_version","v2.0.1","name","FMZ","Copyright © FMZ.COM 版权所有","voucher","https://www.fmz.com/dist/fmz.apk",{"_207":218,"_209":219,"_47":220,"_212":221},{"_207":214,"_209":215,"_47":216,"_212":217},{"_207":208,"_209":210,"_47":211,"_212":213},"source","web3","logo","/upload/asset/ee79a670efe19d2365.svg","MetaMask","platform",[188],"apple","/upload/asset/4416f8d6618c84681e.png","Apple 登录|Apple",[188,147],"google","/upload/asset/102992e886fb7a2fc67.png","Google 登录|Google",[188,147,145],{"_228":242,"_199":243},{"_228":240,"_234":238,"_199":241},{"_228":237,"_234":238,"_199":239},{"_228":233,"_234":235,"_199":236},{"_228":231,"_199":232},{"_228":229,"_199":230},"id",21,"交易插件|Plugin",20,"模板类库|Template",9,"currency","USD","加密货币|Cryptocurrency",2,"CNY","股票证券|Stocks",1,"商品期货|Futures",0,"通用策略|Common",{"_228":237,"_199":287,"_263":249,"_251":264,"_234":235,"_254":288},{"_228":266,"_199":267,"_263":242,"_268":266,"_251":258,"_234":235,"_269":270,"_271":272,"_254":273},{"_228":261,"_199":262,"_263":249,"_251":264,"_234":235,"_254":265},{"_228":256,"_199":257,"_251":258,"_259":202,"_254":260},{"_228":249,"_199":250,"_251":252,"_234":253,"_254":255},3,"余额|Balance","scope","buy","USD,CNY","image","https://www.fmz.com/upload/asset/bc7ac3c0c5e1068a32.png",4,"充值码|Voucher","charge","type","https://www.fmz.com/upload/asset/28fa674166cb24de22b.png",6,"Stripe","amount","charge,buy","https://www.fmz.com/upload/asset/174be2a35fc37c113a6.png",5,"USDT","min","chain",[274,275,276],"description","您只可发送 USDT 至此地址，若发送其他数字货币，您将会失去这笔资金。||only send USDT to this address, you will lose your assets if you send any other crypto","https://www.fmz.com/upload/asset/bb9c83903a6cbfea0f.png",{"_277":284,"_199":285,"_271":286},{"_277":281,"_199":282,"_271":283},{"_277":278,"_199":279,"_271":280},"symbol","TRX","TRC20","Tron Network","ETH","ERC20","Ethereum Network","BNB","BSC","Binance Smart Chain","Paypal","https://www.fmz.com/upload/asset/297a3cb96cf4d1e7736.png",{"_291":305,"_293":306},{"_291":292,"_293":294},"path","/square_bak","banners",[295,296],{"_254":300,"_301":300,"_302":303,"_194":304},{"_297":298,"_194":299},"text","发明者量化平台全球KOL招募令||Financial Magic Zone Global KOL Recruitment","/bbs-topic/10382","/upload/asset/11c9e5536c5d4c1e46e.png","image_dark","height","100px","https://www.jinse.cn/blockchain/3690011.html","/digest",[307],{"_254":300,"_301":300,"_194":304},{"_254":317,"_301":318,"_194":319},{"_254":314,"_301":315,"_194":316},{"_254":311,"_301":312,"_194":313},"/upload/asset/15ce9c5df17eb9af463.png","/upload/asset/309f2b0743dd12d5659.png","/bbs-topic/8238","/upload/asset/2b85d8e0029712de49d.png","/upload/asset/27b5928f8282ebe1864.png","/bbs-topic/1427","/upload/asset/19bb3b1f48c49e196d8.png","/upload/asset/33b98e51d4670de9ce5.png","/bbs-topic/4158",{"_254":321,"_301":322,"_194":323},"/upload/asset/2c2c9521b3a6d0ee73b.png","/upload/asset/2c77ab5db219dc3e78f.png","/bbs-topic/4145",{"_199":354,"_254":355,"_194":356},{"_199":349,"_350":351,"_254":352,"_194":353},{"_199":347,"_254":348,"_194":305},{"_199":344,"_254":345,"_194":346},{"_199":341,"_254":342,"_194":343},{"_199":338,"_254":339,"_194":340},{"_199":335,"_254":336,"_194":337},{"_199":332,"_254":333,"_194":334},"消息中心|Message","/upload/asset/274a5fd7d23a979cd11.png","/messages","工单|Ticket","/upload/asset/11147e72e6c33dc8cba.png","/tickets","交易所|Platform","/upload/asset/318b4addb664da55ea6.png","/platforms","交易终端|Trade","/upload/asset/733e259ec86facf025.png","/trade","社区|Forum","/upload/asset/2e5a8b06b92e5f1357f.png","/bbs","文库|Digest","/upload/asset/1716e895993c78000f3.png","围观|Live","size",30,"/upload/asset/2f23fcaecaa612555f5.png","/live","策略广场|Square","/upload/asset/36bba6d48d47a6689f3.png","/square",{"_254":300,"_301":300,"_194":304},{"_254":372,"_301":373,"_194":374},{"_254":367,"_301":368,"_369":370,"_194":371},{"_254":365,"_301":366,"_194":185},{"_254":362,"_301":363,"_194":364},"/upload/asset/10f6f33ea3b03f80a90.png","/upload/asset/158be7477c0a9a4538a.png","/strategy/520273","/upload/asset/bca3a8d340c888e609.png","/upload/asset/8f0c8df04d8bd94a73.png","/upload/asset/a56df9bdccd3fbcb28.png","/upload/asset/d08dd59b5ac36ed333.png","delay",10000,"/strategy/520272","/upload/asset/de3b761a5c58f67993.png","/upload/asset/18e8a84aec3a5e77ff4.png","/strategy/520274","isAuthenticated","isShadow","balance","fee","isAdmin","hasTwofactor","hasPassword"]