JavaScript

Strategies can be written in JavaScript. The runtime is based on the QuickJS engine and supports modern syntax such as async/await, class and BigInt. In live trading the strategy runs on the docker; in backtesting it runs in the browser-side backtesting system. Adding // @ts-check to the code switches to TypeScript (see Programming Languages → TypeScript).

Structure and parameters

The entry point is function main(). The optional init(), onexit() and onerror(msg) are called automatically by the docker (see Writing Strategies → Strategy Structure). Interface parameters are global variables with the same names; they can be read directly and also modified in code (see Writing Strategies → Strategy Parameters).

Errors and return values

When 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 _C:

            javascript
            
            
function main() {
    var ticker = exchange.GetTicker()
    // null when the call fails
    if (ticker) {
        Log(ticker)
    }

    // retry until valid data is returned
    var account = _C(exchange.GetAccount)
    Log(account)
}

For 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.

Strings and ArrayBuffer

JavaScript 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.

            javascript
            
            
function stringToHex(str) {
    let hex = ''
    for (let i = 0; i < str.length; i++) {
        const charCode = str.charCodeAt(i).toString(16)
        hex += charCode.length === 1 ? '0' + charCode : charCode
    }
    return hex
}

function main() {
    // the code point of "𠮷" exceeds 16 bits; it takes two UTF-16 code units in a JavaScript string
    const inputString = "abc𠮷123"

    // Encode outputs the UTF-8 bytes as hex
    const encodedHex = Encode("raw", "string", "hex", inputString)
    Log(encodedHex)                       // 616263f0a0aeb7313233

    // charCodeAt returns UTF-16 code units, so "𠮷" becomes d842, dfb7 - not UTF-8
    const manuallyEncodedHex = stringToHex(inputString)
    Log(manuallyEncodedHex)               // 616263d842dfb7313233

    // valid UTF-8 bytes decode back to a string
    const decodedString = Encode("raw", "hex", "string", encodedHex)
    Log(decodedString)                    // abc𠮷123

    // bytes that are not valid UTF-8 come back as an ArrayBuffer
    // (with inputString = "abcG123" both encodings are identical and this is a string)
    const outputD = Encode("raw", "hex", "string", manuallyEncodedHex)
    Log(outputD instanceof ArrayBuffer)   // true

    // inspect the raw bytes in the ArrayBuffer
    const bufferD = new Uint8Array(outputD)
    let hexBufferD = ''
    for (let i = 0; i < bufferD.length; i++) {
        hexBufferD += bufferD[i].toString(16).padStart(2, '0')
    }
    Log(hexBufferD)                       // 616263d842dfb7313233
}

Asynchrony and threads

• 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.
• 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.
• 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.
• For concurrency use exchange.Go, HttpQuery_Go, or create threads with Thread (see Advanced Topics → JavaScript Multithreading).

            javascript
            
            
async function main() {
    let resp = await fetch("https://www.okx.com/api/v5/market/books?instId=BTC-USDT")
    if (resp.ok) {
        Log(resp.json())
    } else {
        Log("status:", resp.status)
    }
}

Libraries and dependencies

JavaScript strategies can use the built-in TA and talib indicator libraries directly; see Writing Strategies → Built-in Libraries for what each language provides. Other third-party JavaScript libraries can be downloaded at run time and loaded with eval; the same page has an example.

TypeScript

TypeScript is not a separate language option. Create the strategy as JavaScript and add a // @ts-check line to the code (or click the "TypeScript" button at the top right of the editor); the platform then treats it as TypeScript and compiles it to JavaScript before backtesting or live trading. When a strategy is saved through the AI/MCP tools, the language can be given as typescript: the platform saves it as a JavaScript strategy and adds //@ts-check at the top automatically (see External Interfaces → AI Access).

Static type checking catches mistakes such as wrong argument counts, property names or types while you write, and makes editor completion more accurate.

A minimal example:

            ts
            
            
// @ts-check
interface Signal {
    side: "buy" | "sell"
    price: number
}

function getSignal(ticker: ITicker, ma: number): Signal | null {
    if (ticker.Last > ma) {
        return {side: "buy", price: ticker.Last}
    }
    if (ticker.Last < ma) {
        return {side: "sell", price: ticker.Last}
    }
    return null
}

function main() {
    while (true) {
        const records = exchange.GetRecords()
        const ticker = exchange.GetTicker()
        if (records && ticker && records.length > 20) {
            const ma = TA.MA(records, 20)
            const signal = getSignal(ticker, ma[ma.length - 1])
            if (signal) {
                Log(signal.side, signal.price)
            }
        }
        Sleep(60 * 1000)
    }
}

Type declarations for the platform API are built into the strategy editor; nothing needs to be referenced in the code. They cover the global functions, the exchange object, data structure interfaces such as ITicker, IRecord, IOrder and IPosition, and TA, talib and so on. Language features, APIs and libraries at run time are the same as for JavaScript strategies (see Programming Languages → JavaScript).

Python

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.

Interpreter

The docker looks for an interpreter in this order and uses the first program that starts and is Python 3:

1. the interpreter given by the environment variable PYTHON_BIN;
2. python3;
3. python.

To use a specific interpreter (for example the Python of a virtual environment), set the environment variable before starting the docker:

            bash
            
            
export PYTHON_BIN=/opt/venv/bin/python3

A first line such as #!python3 or #!python2 in the strategy is no longer used to choose the interpreter.

Structure and parameters

The entry point is def main(). The optional init() and onexit() are called automatically by the docker (Python does not support onerror()); see Writing Strategies → Strategy Structure. Interface parameters are global variables with the same names; to assign a new value to one inside a function, declare it with global first.

Errors and return values

When 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.

Output

The output of print() goes to the docker process's standard output and does not appear in the live trading log. Use Log for anything that should show up in the log.

Third-party packages

A strategy can import any package installed in the interpreter. Install packages with the same interpreter the docker uses, for example:

            bash
            
            
python3 -m pip install numpy
# when PYTHON_BIN is set
$PYTHON_BIN -m pip install numpy

To use talib, install TA-Lib (the talib package) and numpy on the docker's machine.

Your own modules

While a strategy runs, its current directory and PYTHONPATH are a temporary directory created by the docker for that run and deleted afterwards; .py files placed under the docker's directory (for example logs/storage/<live trading ID>/) are not found automatically. There are two ways to import your own modules:

• 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);
• in the strategy, append the absolute path of the module's directory to sys.path, then import it.

For example, with the module file /home/user/fmz_modules/mymath.py:

            python
            
            
# mymath.py
def add(a, b):
    return a + b

the strategy code is:

            python
            
            
import sys
sys.path.append("/home/user/fmz_modules")   # absolute path of the module's directory

import mymath

def main():
    Log("mymath.add(1, 2):", mymath.add(1, 2))

Keeping 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.

Rust

Strategies can be written in Rust. Rust strategies are compiled before they run: for backtesting the platform server compiles them and they run in the browser-side backtesting system; in live trading they run on the docker once compiled. The strategy editor integrates rust-analyzer for Rust, with code completion and live diagnostics.

Structure

A 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.

The 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.

            rust
            
            
fn init() {
    Log!("initializing");
}

fn main() {
    // APIs that can fail return Result<T>; the _C! macro retries until the call succeeds
    let ticker = _C!(exchange.GetTicker(None));
    Log!("Last:", ticker.Last);
}

fn onexit() {
    Log!("strategy exiting, cleaning up");
}

Some functions are macros (note the exclamation mark): Log!(), LogStatus!(), Panic!(), _G!(), _C!(). LogProfit(), Sleep(), _D(), _N(), HttpQuery() and others are ordinary functions.

Parameter types

Interface 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:

• Convert explicitly where an integer is needed, for example let n = Period as usize;.
• 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.
• 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):

            rust
            
            
fn main() {
    let key: &str = &*ApiKey;   // ApiKey is an encrypted-string parameter
    Log!("key length:", key.len());
}

• If a parameter name clashes with another name in the code, refer to the parameter as args::ParamName.

Errors and return values

API calls that can fail return Result<T>; handle it the usual Rust way (in JavaScript a failed call returns null):

            rust
            
            
fn main() {
    // option 1: pattern matching
    if let Ok(ticker) = exchange.GetTicker(None) {
        Log!(ticker);
    }

    // option 2: the _C! macro retries until the call succeeds
    let ticker = _C!(exchange.GetTicker(None));
    Log!(ticker);
}

Optional arguments (such as the symbol argument of GetTicker) are passed as None when omitted, or given directly, for example exchange.GetTicker("BTC_USDT").

JSON

Raw 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<JsonValue>. 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.

Third-party crates

The 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:

            rust
            
            
---
[dependencies]
serde_json = "1"
---
/*backtest
start: 2024-01-01 00:00:00
end: 2024-02-01 00:00:00
period: 1h
*/
fn main() {
    let v: serde_json::Value = serde_json::from_str(r#"{"a": 1}"#).unwrap();
    Log!("a:", v["a"].to_string());
}

• The frontmatter must be at the start of the source, with only blank lines before it; the /*backtest ... */ backtest configuration block goes after the closing ---. If the strategy has no backtest configuration block yet, "Save Backtest Settings" inserts one at the very top of the source; move it below the frontmatter (later saves update it in place).
• 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.
• 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 Dial function, which needs no third-party crate.

Built-in libraries

Rust strategies can use the TA indicator library; talib is not supported. See Writing Strategies → Built-in Libraries.

MyLanguage

The platform supports MyLanguage for writing and designing strategies, compatible with most syntax, instructions and functions of Wenhua MyLanguage. MyLanguage encourages modular programming, breaking down complex algorithms into function modules. Through concise syntax, dedicated data structures and powerful financial function libraries, it supports the implementation of complex financial logic. Building applications in a modular way improves development efficiency and code maintainability.

MyLanguage Strategy Example: System Based on Displaced Bollinger Bands

            mylang
            
            
M := 12;          // Parameter range 1, 20
N := 3;           // Parameter range 1, 10
SDEV := 2;        // Parameter range 1, 10
P := 16;          // Parameter range 1, 20

// This strategy is a trend-following trading strategy, suitable for larger timeframes such as daily charts.
// This model is only used as a model development case. Trading based on this carries your own risk.

////////////////////////////////////////////////////////

// Displaced BOLL channel calculation
MID:=MA(C,N);                 // Calculate middle band
TMP:=STD(C,M)*SDEV;           // Calculate standard deviation
DISPTOP:=REF(MID,P)+TMP;      // Displaced BOLL channel upper band
DISPBOTTOM:=REF(MID,P)-TMP;   // Displaced BOLL channel lower band

// System entry
H>=DISPTOP,BPK;
L<=DISPBOTTOM,SPK;
AUTOFILTER;

• FMZ Quant MyLanguage Documentation
• FMZ Quant MyLanguage--MyLanguage Trading Library Parameters

PINE Language

The platform supports and is compatible with Trading View's PINE language scripts. PINE is a lightweight yet powerful strategy programming language for creating technical indicators and strategies that can be backtested and traded live. The active community has created over 100,000 PINE scripts.
Users can easily access and apply various technical analysis tools and trading strategies; leverage community scripts to quickly implement trading ideas without writing code from scratch, significantly reducing development cycles; help both beginners and experienced traders learn and understand different technical indicators, strategies, and programming concepts.

PINE Language Strategy Example: Supertrend Strategy

            pine
            
            
strategy("supertrend", overlay=true)

[supertrend, direction] = ta.supertrend(input(5, "factor"), input.int(10, "atrPeriod"))
plot(direction < 0 ? supertrend : na, "Up direction", color = color.green, style=plot.style_linebr)
plot(direction > 0 ? supertrend : na, "Down direction", color = color.red, style=plot.style_linebr)

if direction < 0
    if supertrend > supertrend[2]
        strategy.entry("entry long", strategy.long)
    else if strategy.position_size < 0
        strategy.close_all()
else if direction > 0
    if supertrend < supertrend[3]
        strategy.entry("entry short", strategy.short)
    else if strategy.position_size > 0
        strategy.close_all()

• PINE Script Documentation

Blockly Visual Programming

The platform supports Blockly visual programming. With the Blockly editor, users can express code concepts such as variables, logical expressions, and loops by connecting graphical blocks (similar to building blocks). This approach allows the programming process to focus less on tedious syntax details and instead operate directly according to programming principles. Through the arrangement and combination of graphical blocks, users can easily understand programming logic and implement creative ideas, making it ideal for cultivating interest in strategy design and quickly getting started with programmatic and quantitative trading.

• Building Trading Strategies with Visual Modules - Introduction

• Building Trading Strategies with Visual Modules - Advanced

• Building Trading Strategies with Visual Modules - In-depth

• Building Trading Strategies with Visual Modules - Simplified

Workflow

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.

Workflow Features:

• Visual drag-and-drop design, WYSIWYG
• Rich preset functional nodes (data retrieval, indicator calculation, conditional judgment, trade execution, etc.)
• Lower programming barrier, suitable for rapid strategy building and validation
• Supports backtesting functionality with visual node execution status viewing

Learning Resources:

• Workflow Video Tutorial Series

init()

init() is the initialization function implemented by the user. When a strategy starts running, the init() function is automatically executed first to complete the initialization tasks designed within the strategy.

Examples

    javascript
    
    
function main(){
    Log("First line of code executed!", "#FF0000")
    Log("Exiting!")
}

// Initialization function
function init(){
    Log("Initializing!")
}

    python
    
    
def main():
    Log("First line of code executed!", "#FF0000")
    Log("Exiting!")

def init():
    Log("Initializing!")

    rust
    
    
fn main() {
    Log!("First line of code executed!", "#FF0000");
    Log!("Exiting!");
}

// Initialization function
fn init() {
    Log!("Initializing!");
}

onexit()

onexit() is implemented by the user to clean up when the strategy exits; it is optional. It may run for at most 5 minutes and is terminated when it exceeds that. For when each language calls onexit(), see Writing Strategies → Strategy Structure.

Examples

• Testing the onexit() function:

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main(){
      Log("Starting, will stop after 5 seconds and execute cleanup function!")
      Sleep(1000 * 5)
  }
  
  // cleanup function
  function onexit(){
      var beginTime = new Date().getTime()
      while(true){
          var nowTime = new Date().getTime()
          Log("Program stop countdown..cleanup started, elapsed time:", (nowTime - beginTime) / 1000, "seconds!")
          Sleep(1000)
      }
  }
  

  
      python
      
      
  import time
  def main():
      Log("Starting, will stop after 5 seconds and execute cleanup function!")
      Sleep(1000 * 5)
  
  def onexit():
      beginTime = time.time() * 1000
      while True:
          ts = time.time() * 1000
          Log("Program stop countdown..cleanup started, elapsed time:", (ts - beginTime) / 1000, "seconds!")
          Sleep(1000)
  

  
      rust
      
      
  fn main() {
      Log!("Starting, will stop after 5 seconds and execute cleanup function!");
      Sleep(1000 * 5);
  }
  
  // cleanup function
  fn onexit() {
      let beginTime = Unix() * 1000;
      loop {
          let nowTime = Unix() * 1000;
          Log!("Program stop countdown..cleanup started, elapsed time:", (nowTime - beginTime) / 1000, "seconds!");
          Sleep(1000);
      }
  }
  

• In the backtesting system a strategy is usually an endless polling loop, so main() has not returned normally when the backtest data ends, and JavaScript and Python strategies therefore do not run onexit(). In a backtest (IsVirtual() is true) you can catch the exception (EOF) thrown when the backtest ends so that main() returns and onexit() runs. In Rust the API calls return Err when the backtest ends, so just leave the loop.

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main() {
      if (exchange.GetName().startsWith("Futures_")) {
          Log("Exchange is futures")
          exchange.SetContractType("swap")
      } else {
          Log("Exchange is spot")
      }
  
      if (IsVirtual()) {
          try {
              onTick()
          } catch (e) {
              Log("error:", e)
          }
      } else {
          onTick()
      }
  }
  
  function onTick() {
      while (true) {
          var ticker = exchange.GetTicker()
          LogStatus(_D(), ticker ? ticker.Last : "--")
          Sleep(500)
      }
  }
  
  function onexit() {
      Log("Executing cleanup function")
  }
  

  
      python
      
      
  def main():
      if exchange.GetName().startswith("Futures_"):
          Log("Exchange is futures")
      else:
          Log("Exchange is spot")
  
      if IsVirtual():
          try:
              onTick()
          except Exception as e:
              Log(e)
      else:
          onTick()
  
  def onTick():
      while True:
          ticker = exchange.GetTicker()
          LogStatus(_D(), ticker["Last"] if ticker else "--")
          Sleep(500)
  
  def onexit():
      Log("Executing cleanup function")
  

  
      rust
      
      
  fn onTick() {
      loop {
          match exchange.GetTicker(None) {
              Ok(ticker) => LogStatus!(_D(None), ticker.Last),
              Err(e) => {
                  // API calls return Err when the backtest ends; leaving the loop lets main return, which triggers onexit()
                  Log!("error:", e);
                  break;
              }
          }
          Sleep(500);
      }
  }
  
  fn main() {
      if exchange.GetName().starts_with("Futures_") {
          Log!("Exchange is futures");
          let _ = exchange.SetContractType("swap");
      } else {
          Log!("Exchange is spot");
      }
  
      onTick();
  }
  
  fn onexit() {
      Log!("Executing cleanup function");
  }
  

onerror()

onerror(msg) is supported only by JavaScript (including TypeScript) strategies. It is called when main() ends with an uncaught exception; the argument msg is the error message. When onerror() is called, onexit() is not. It may run for at most 5 minutes and is terminated when it exceeds that. The backtesting system does not support this function.

Python and Rust strategies do not support onerror().

Examples

    javascript
    
    
function main() {
    var arr = []
    Log(arr[6].Close)  // deliberately raise an exception here
}

function onerror(msg) {
    Log("Error:", msg)
}

    python
    
    
# Not supported in Python

    rust
    
    
// Not supported in Rust

Main Loop

A strategy usually runs a loop in main(): each round fetches market data, computes signals, places orders, then calls Sleep to wait for the next round. In backtesting Sleep() advances backtest time and controls the replay speed; in live trading it controls the polling interval and therefore how often the exchange API is called. A loop without Sleep() calls the exchange API as fast as it can and easily hits the exchange's rate limits. To limit the API call rate on the docker, see Advanced Topics → API Rate Limit Control.

Examples

• Basic framework:

  • javascript
  • python
  • rust

  
      javascript
      
      
  function onTick(){
      // strategy logic goes here and is called repeatedly, e.g. print market data
      Log(exchange.GetTicker())
  }
  
  function main(){
      while(true){
          onTick()
          // Sleep controls the polling frequency so the exchange API is not called too often
          Sleep(60000)
      }
  }
  

  
      python
      
      
  def onTick():
      Log(exchange.GetTicker())
  
  def main():
      while True:
          onTick()
          Sleep(60000)
  

  
      rust
      
      
  fn onTick() {
      // strategy logic goes here and is called repeatedly, e.g. print market data
      Log!(exchange.GetTicker(None));
  }
  
  fn main() {
      loop {
          onTick();
          // Sleep controls the polling frequency so the exchange API is not called too often
          Sleep(60000);
      }
  }
  

• The simplest example: place a buy order at price 100 for amount 1 every second:

  • javascript
  • python
  • rust

  
      javascript
      
      
  function onTick(){
      // only an example: it quickly spends all funds on orders, do not run it live
      exchange.Buy(100, 1)
  }
  
  function main(){
      while(true){
          onTick()
          // the pause is in milliseconds; 1 second = 1000 milliseconds
          Sleep(1000)
      }
  }
  

  
      python
      
      
  def onTick():
      exchange.Buy(100, 1)
  
  def main():
      while True:
          onTick()
          Sleep(1000)
  

  
      rust
      
      
  fn onTick() {
      // only an example: it quickly spends all funds on orders, do not run it live
      let _ = exchange.Buy(100, 1);
  }
  
  fn main() {
      loop {
          onTick();
          // the pause is in milliseconds; 1 second = 1000 milliseconds
          Sleep(1000);
      }
  }
  

• A strategy that acts on K-line updates (On Bar): onTick() runs only when the time of the latest K-line changes:

  • javascript
  • python
  • rust

  
      javascript
      
      
  function onTick() {
      Log("K-line updated, new BAR generated")
  }
  
  function main() {
      var exName = exchange.GetName()
      if (exName.includes("Futures_")) {
          exchange.SetContractType("swap")
      }
  
      var lastTs = 0
      while (true) {
          var r = _C(exchange.GetRecords)
          if (r.length > 0 && r[r.length - 1].Time != lastTs) {
              onTick()
              lastTs = r[r.length - 1].Time
          }
          Sleep(1000)
      }
  }
  

  
      python
      
      
  def onTick():
      Log("K-line updated, new BAR generated")
  
  def main():
      exName = exchange.GetName()
      if "Futures_" in exName:
          exchange.SetContractType("swap")
  
      lastTs = 0
      while True:
          r = _C(exchange.GetRecords)
          if len(r) > 0 and r[-1]["Time"] != lastTs:
              onTick()
              lastTs = r[-1]["Time"]
          Sleep(1000)
  

  
      rust
      
      
  fn onTick() {
      Log!("K-line updated, new BAR generated");
  }
  
  fn main() {
      let exName = exchange.GetName();
      if exName.contains("Futures_") {
          let _ = exchange.SetContractType("swap");
      }
  
      let mut lastTs = 0;
      loop {
          let r = _C!(exchange.GetRecords(None, None, None));
          if r.len() > 0 && r[r.len() - 1].Time != lastTs {
              onTick();
              lastTs = r[r.len() - 1].Time;
          }
          Sleep(1000);
      }
  }
  

Event-Driven

Besides polling at a fixed interval, a strategy can wait for events and handle them as they arrive, which avoids useless requests and reacts faster to market changes.

EventLoop

EventLoop waits for events such as the completion of concurrent tasks started with exchange.Go() or HttpQuery_Go(), readable data on a WebSocket connection, or thread messages; when one occurs it returns the event information and the strategy then reads the corresponding data. Events are recorded only from the first call of EventLoop(), so call EventLoop(-1) once before starting concurrent tasks:

            javascript
            
            
function main() {
    EventLoop(-1)                       // start recording events so none are missed
    var r1 = exchange.Go("GetTicker")
    var r2 = exchange.Go("GetDepth")
    var ev = EventLoop(1000)            // wait up to 1 second for either task to finish
    Log("event:", ev)
    Log("ticker:", r1.wait(), "depth:", r2.wait())
}

ctx.subscribe / ctx.poll

JavaScript and Rust strategies can also use the docker's event subscription interface: ctx.subscribe() subscribes to market data or order updates for an account and symbol and returns a stream ID; ctx.poll() takes the next event (optionally with a timeout), and the strategy handles it according to its kind. Python strategies do not support it.

            javascript
            
            
function main() {
    ctx.subscribe(0, "BTC_USDT", {channel: "ticker"})   // the first argument is the account's index in exchanges
    ctx.subscribe(0, "", {channel: "orders"})           // order updates
    while (true) {
        const ev = ctx.poll([], 1000)                    // [] means all subscriptions; wait up to 1 second
        if (!ev) {
            continue
        }
        if (ev.kind === 1) {
            Log("ticker:", ev.symbol, ev.bid, ev.ask, ev.last)
        } else if (ev.kind === 16) {
            Log("order:", ev.id, ev.state, ev.filledQty)
        }
    }
}

• channel can be "ticker", "bbo", "depth", "trade", "kline" (interval is the period in seconds) or "orders".
• Event kind: 1 ticker, 3 depth (the event only signals that the order book changed; read the levels with ctx.book(ev.ex, ev.symbol, n)), 4 trade, 5 K-line, 16 order update.
• If market data subscriptions are not consumed in time, only the latest data is kept or the oldest is dropped; order updates are never dropped, so the strategy must keep calling ctx.poll().

In Rust the calls are ctx::subscribe() and ctx::poll(); events are raw structures whose prices and quantities are fixed-point integers:

            rust
            
            
fn main() {
    let s = ctx::subscribe(0, "BTC_USDT", ctx::SubOpts::ticker()).unwrap();
    loop {
        match ctx::poll(&[s], Some(1000)) {
            ctx::Polled::Event(ev) => Log!("event kind:", ev.kind),
            ctx::Polled::Stopped => break,
            _ => {}
        }
    }
}

API Quick Reference

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.

Built-in Functions

Global

Log

Market

Trade

Account

Futures

Exchange

IO

Network

Storage

Threads

Threads/threading

Threads/Thread

Threads/ThreadLock

Threads/ThreadEvent

Threads/ThreadCondition

Threads/ThreadDict

Threads/Server

Web3

Uniswap

TA

Talib/OverlapStudies

Talib/MomentumIndicators

Talib/VolumeIndicators

Talib/VolatilityIndicators

Talib/CycleIndicators

Talib/PriceTransform

Talib/StatisticFunctions

Talib/MathTransform

Talib/MathOperators

Talib/PatternRecognition

OS

OS/os

OS/File

Structures

OtherStruct

Built-in Variables and Constants

EXCHANGE

ORDER_STATE

ORDER_TYPE

ORDER_CONDITION_TYPE

POSITION_DIRECTION

ORDER_OFFSET

PERIOD

LOG_TYPE

Interface Parameter Types

Interface parameters are configured in the strategy parameters area below the code editor on the strategy editing page. Please note the following:

1. In the default value option of parameter settings, the "Optional" control is optional by default. You can change the state of this control to set the current parameter as required. After setting a parameter as required, if the parameter is not set during backtesting or live trading, backtesting cannot be performed or live trading cannot be started.
2. Variable names for interface parameters in strategy code should not use reserved words (keywords) of the current programming language.
3. In the backtesting or live trading interface, hovering the mouse over the control bound to a parameter will display the parameter's remarks.
4. The "Description" of a parameter is the display name of the control bound to the parameter.
5. The "Variable" of a parameter refers to those in the table above: pNum, pBool, pStr, pCombox, pSecretStr. They exist as global variables in the strategy code, so the values of strategy parameters can be modified in the code (except in Rust, where parameters are global constants and cannot be modified).
6. For "Encrypted string" and "String" type parameters, no quotes are needed when entering default values; all input is treated as strings. "Encrypted string" parameters are used the same way as "String" parameters, but encrypted strings are transmitted encrypted and not sent in plain text.
7. If a "String" type parameter is set to "Optional", when no parameter is filled in the control bound to the parameter, the value of the parameter variable is empty string;
   Similarly, the value of a "Numeric" parameter is null;
   Similarly, the value of a "Dropdown" parameter is null;
   Similarly, the value of an "Encrypted string" parameter is null.
   In Rust strategies, an optional parameter that is left empty has the zero value of its type: 0 for numbers, an empty string for strings and encrypted strings, false for booleans.
8. For dropdown type interface parameters (e.g., variable name pCombox), when "Support multiple selection" is not enabled in "Component Configuration", the value of pCombox is the index or specific data of the currently selected option (when data is bound to options).
   If "Support multiple selection" is enabled, the value of pCombox is an array containing the indices or specific data of all currently selected options (when data is bound to options).

Component Configuration

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.

Components supported by each type:

• Number (number)
  Input box (default), time picker, slider.
• Boolean (true/false)
  Switch only (default).
• String (string)
  Input box (default), text box, time picker, color picker, currency, trading symbol.
• Dropdown (selected)
  Dropdown (default), segmented control, currency, trading symbol.
• Encrypted string (string), strategy parameters only
  Encrypted input box only (default).
• Button (button), interactive controls only
  A single button (default), with no input.

Group

Enter 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).

Filter

In 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. Expressions such as a > b, a == 1, a, !a and a >= 1 && a <= 10 can be used. The parameter is available when the condition is true.

• With the filter a == 1, the parameter's availability depends on the value of parameter a: it is available when a equals 1, otherwise not.
• With the filter a >= 1 && a <= 10, the parameter is available when a is greater than or equal to 1 and less than or equal to 10, otherwise not.
• With the filter !a, the condition is "not a"; a can be a boolean or a number (!0 is true).

Save Parameter Settings

• Parameter saving in the backtesting system
  When backtesting, if you want to save the strategy parameters, you can click the "Save Backtest Settings" button after modifying the strategy parameters. For details, see Backtesting System → Backtest Configuration and Saving.

  Variable	Description	Type	Default Value
  number	Numeric type	Number (number)	1
  string	String	String (string)	Hello FMZ
  combox	Dropdown box	Dropdown (selected)	1|2|3
  bool	Boolean value	Boolean (true/false)	true
  numberA@isShowA	Numeric A	Number (number)	2
  isShowA	Whether to display the numberA parameter	Boolean (true/false)	false

  The configured strategy parameters will be saved in the strategy in the form of code, for example:

  • Javascript
  • Python
  • Rust

  
              javascript
              
              
  /*backtest
  start: 2020-02-29 00:00:00
  end: 2020-03-29 00:00:00
  period: 1d
  args: [["number",2],["string","Hello FMZ.COM"],["combox",2],["bool",false],["numberA@isShowA",666],["isShowA",true]]
  */
  

  
              python
              
              
  '''backtest
  start: 2020-02-29 00:00:00
  end: 2020-03-29 00:00:00
  period: 1d
  args: [["number",2],["string","Hello FMZ.COM"],["combox",2],["bool",false],["numberA@isShowA",666],["isShowA",true]]
  '''
  

  
              rust
              
              
  /*backtest
  start: 2020-02-29 00:00:00
  end: 2020-03-29 00:00:00
  period: 1d
  args: [["number",2],["string","Hello FMZ.COM"],["combox",2],["bool",false],["numberA@isShowA",666],["isShowA",true]]
  */
  

  If a Rust strategy declares dependencies in a frontmatter block at the top, the backtest configuration block must come after the frontmatter (see Programming Languages → Rust).

• Importing and exporting live trading parameters
  When running live trading, if you need to save the parameter data of the live trading configuration, you can click the "Parameter Settings" option on the strategy live trading page, then click the "Export Parameters" button. The exported strategy parameters will be saved as a json file.
  The exported strategy parameter configuration can also be imported into live trading again. Click the "Import Parameters" button to import the saved strategy live trading parameters into the current live trading, and after importing, click the "Update Parameters" button to save and apply them.

Types of Interactive Controls

Messages (strings) sent to the strategy after interactive control is triggered:

• Number type
  After entering interactive data 123 in the input box of interactive control cmdNum, click the button of interactive control cmdNum. The GetCommand() function in the strategy program will receive the message: cmdNum:123.
• Boolean type
  After setting the switch control of interactive control cmdBool to on, click the button of interactive control cmdBool. The GetCommand() function in the strategy program will receive the message: cmdBool:true.
• String type
  After entering interactive data abc in the input box of interactive control cmdStr, click the button of interactive control cmdStr. The GetCommand() function in the strategy program will receive the message: cmdStr:abc.
• Dropdown
  After selecting the second option in the dropdown of interactive control cmdCombox, click the button of interactive control cmdCombox. The GetCommand() function in the strategy program will receive the message: cmdCombox:1, where 1 represents the index of the selected option, the first option has index 0, the second option has index 1.
• Button
  Click the button of interactive control cmdBtn. The GetCommand() function in the strategy program will receive the message: cmdBtn.

The "Component Configuration" of interactive controls is the same as for strategy parameters (see Strategy Parameters → Component Configuration).

Example: changing a strategy parameter with an interactive control

On the strategy editing page, add a string interactive control named changeSymbol under "Strategy Interaction". The settings of the interactive control:

While 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):

            javascript
            
            
// strategy parameter
var symbol = "BTC_USDT"

function main() {
    while (true) {
        var cmd = GetCommand()
        if (cmd) {
            var arr = cmd.split(":")
            if (arr.length == 2 && arr[0] == "changeSymbol") {
                // the changeSymbol control was triggered: update the parameter
                Log("Changed symbol parameter to:", arr[1])
                symbol = arr[1]
            }
        }

        LogStatus(_D(), ", Current symbol parameter value:", symbol)
        Sleep(3000)
    }
}

Interactive Controls in Status Bar

In addition to designing interactive controls in the "Strategy Interaction" section, you can also design interactive controls in the strategy status bar. Currently, the only supported interactive control type is the button type. See LogStatus.

Button controls in the status bar can be divided into:

• Regular button controls
  Data structure example:

  
              json
              
              
  {"type": "button", "name": "Button 1", "cmd": "button1", "description": "This is the first button"}
  

• Button controls with a single input data
  Use the input attribute to set input control options. Data structure example:

  
              json
              
              
  {"type": "button", "name": "Button 2", "cmd": "button2", "description": "This is the second button", "input": {"name": "Open Quantity", "type": "number", "defValue": 1}}
  

  
              json
              
              
  {
      "type": "button",
      "cmd": "test1",
      "name": "test1",
      "input": {
          "type": "selected",
          "name": "selected",
          "label": "Dropdown",
          "description": "description",
          "default": 100,
          "settings": {
              "multiple": true,
              "customizable": true,
              "options":[{"name": "A", "value": 100}, {"name": "B", "value": 200}]
          }
      }
  }
  

• Button controls with a group of input data
  Use the group attribute to set options for a group of input controls. Data structure example:

  
              json
              
              
  {
      "type": "button",
      "cmd": "open",
      "name": "Open",
      "group": [
          {"name": "orderType", "description": "Order Method|order type", "type": "selected", "defValue": "Market Order|Limit Order"},
          {"name": "tradePrice@orderType==1", "description": "Trade Price|trade price", "type": "number", "defValue": 100},
          {"name": "orderAmount", "description": "Order Quantity|order amount", "type": "string", "defValue": 100},
          {"name": "boolean", "description": "Yes/No|boolean", "type": "boolean", "defValue": true}
      ]
  }
  

  
              json
              
              
  {
      "type": "button",
      "cmd": "test2",
      "name": "test2",
      "group": [{
          "type": "selected",
          "name": "selected",
          "label": "Dropdown",
          "description": "description",
          "default": 200,
          "group": "group1",
          "settings": {
              "multiple": true,
              "options":[{"name": "A", "value": 100}, {"name": "B", "value": 200}]
          }
      }, {
          "type": "string",
          "name": "string",
          "label": "Input Box",
          "description": "description",
          "default": "ABC",
          "group": "group1"
      }]
  }
  

Encode the JSON data of these button controls as a JSON string, then wrap it with ` characters and output it in the status bar. Using JavaScript as an example:

            javascript
            
            
function main() {
    var btn = {"type": "button", "name": "Button 1", "cmd": "button1", "description": "This is the first button"}
    LogStatus("`" + JSON.stringify(btn) + "`")
}

These button controls can also be written into status bar tables. For detailed examples see LogStatus.

The input field structure is consistent with the single control structure in the group field. The following is a detailed explanation (an annotated JavaScript object):

            javascript
            
            
{
    "type": "selected",     // Control type (required field), supports: number, string, selected, boolean
    "name": "test",         // Name (required field when used in group)
    "label": "topic",       // Title (required field)
    "description": "desc",  // Tooltip information for the component
    "default": 1,           // Default value; if the settings field is not set in the current JSON structure, it is compatible with defValue, and defValue can be used instead of default
    "filter": "a>1",        // Selector, not setting this field means no filtering (display control); when this field is set, the control is not filtered (displayed) when the expression is true, and filtered (not displayed) when the expression is false
                            // For the selector, using the expression a>1 in this example, 'a' refers to the control value with name 'a' under the group field in the type=button structure, and this value is used to determine whether to filter
    "group": "group1",      // Grouping
    "settings": {}          // Component configuration, fields described below
}

Detailed explanation of each field in the component configuration settings:

• settings.required: Whether it is required.
• settings.disabled: Whether it is disabled.
• settings.min: Valid when type=number, represents the minimum value.
• settings.max: Valid when type=number, represents the maximum value.
• settings.step: Valid when type=number and render=slider, represents the step size.
• settings.multiple: Valid when type=selected, indicates support for multiple selection.
• settings.customizable: Valid when type=selected, indicates support for customization; users can directly edit and add new options in the dropdown control. If a newly edited option is selected, the option's name will be used instead of the option's value when triggering the interaction.
• settings.options: Valid when type=selected, represents the selector's option data format: ["Option 1", "Option 2"], [{'name':'xxx','value':0}, {'name':'xxx','value':1}].
• settings.render: Render component type.
  When type=number, settings.render is not set (defaults to number input box), options: slider (slider), date (date picker, returns timestamp).
  When type=string, settings.render is not set (defaults to single-line input box), options: textarea (multi-line input), date (date picker, returns yyyy-MM-dd hh:mm:ss), color (color picker, returns #FF00FF).
  When type=selected, settings.render is not set (defaults to dropdown), options: segment (segmented selector).
  When type=boolean, currently only the default checkbox is available.

Bilingual settings are supported. For example, the text '选项|options' adapts to the current language. Using a single control in the group field as an example, a complete example (a JavaScript object):

            javascript
            
            
{
    type:'selected',
    name:'test',
    label:'选项|options',
    description:'描述|description',
    default:0,                            // Here the default value is set to 0, representing the value in {name:'xxx|yyy',value:0} option
    filter:'a>1&&a<10',
    group:'Group|group',
    settings:{
        multiple:true,
        customizable:true,
        options:[{name:'xxx|yyy',value:0}]
    }
}

Export Functions of Template Libraries

Export functions are the interface functions of template libraries, which can be called by strategies that reference the template library.

Examples

• Different programming languages have different formats for writing template libraries. The following are example codes for declaring and implementing export functions in template libraries:

  • javascript
  • python
  • rust

  
      javascript
      
      
  /*
  -- 策略引用该模板以后直接用 $.Test() 调用此方法
  -- main 函数在策略中不会触发, 只做为模板调试的入口
  */
  $.Test = function() {
      Log('Test')
  }
  
  function main() {
      $.Test()
  }
  

  
      python
      
      
  def Test():
      Log("template call")
  
  # 导出Test函数, 主策略可以通过ext.Test()调用
  ext.Test = Test

  
      rust
      
      
  // after referencing this template, a strategy calls it as ext::Test()
  // functions called by the strategy must be declared pub
  pub fn Test() {
      Log!("template call");
  }
  

• Strategies written in Blockly visual mode can implement library functions through JavaScript language template libraries. Please use the following format.

  
              javascript
              
              
  /*blockly
      {
          "type": "ext_testA",
          "message0": "testA|testA",
          "template": "function(){return 99;}()",
          "order": "ORDER_ATOMIC",
          "output": "Number"
      },{
          "type": "ext_MA",
          "message0": "MA 周期 %1| MA Period %1",
          "args0": [{
              "type": "input_value",
              "check": "Number"
          }],
          "template": "(function(){var r = exchange.GetRecords(); return (!r || r.length < %1) ? false : TA.MA(r, %1); })()",
          "order": "ORDER_ATOMIC",
          "output": null,
          "colour": 85
      }
  */
  

Template Library Parameters

Template libraries can also set their own interface parameters. Template library parameters are used as global variables in the template library code.

For example, we set a template library parameter:

Parameters of a Rust template are constants that can only be read, not modified, so in Rust the example below can only read the parameter:

            rust
            
            
// template code
pub fn GetParam1() -> f64 {
    Log!("param1:", param1);
    param1
}

            rust
            
            
// strategy code
fn main() {
    Log!("Calling ext::GetParam1:", ext::GetParam1());
}

Examples

• Template library code for testing the param1 parameter:

  • javascript
  • python
  • rust

  
      javascript
      
      
  $.SetParam1 = function(p1) {
      param1 = p1
  }
  
  $.GetParam1 = function() {
      Log("param1:", param1)
      return param1
  }

  
      python
      
      
  def SetParam1(p1):
      global param1
      param1 = p1
  
  def GetParam1():
      Log("param1:", param1)
      return param1
  
  ext.SetParam1 = SetParam1
  ext.GetParam1 = GetParam1

  
      rust
      
      
  // Rust template parameters are read-only constants; see above for how to read them
  

• Strategy code referencing the above template library example, using the template library's exported functions to get parameter param1 and modify parameter param1.

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main () {
      Log("Calling $.GetParam1:", $.GetParam1())
      Log("Calling $.SetParam1:", "#FF0000")
      $.SetParam1(20)
      Log("Calling $.GetParam1:", $.GetParam1())
  }

  
      python
      
      
  def main():
      Log("Calling ext.GetParam1:", ext.GetParam1())
      Log("Calling ext.SetParam1:", "#FF0000")
      ext.SetParam1(20)
      Log("Calling ext.GetParam1:", ext.GetParam1())
  

  
      rust
      
      
  // Rust template parameters are read-only constants; see above for how to read them
  

Reference Template Library

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, check the templates you need to reference in the Template section, then save the strategy to complete the reference.