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