exchange.Buy

The exchange.Buy() function is used to place a buy order. The Buy() function is a member function of the exchange object exchange. The Buy() function operates on the exchange account bound to the exchange object exchange. The purpose of member functions (methods) of the exchange object is only related to exchange, which will not be repeated in subsequent documentation.

    
    
    
exchange.Buy(price, amount)

    
    
    
exchange.Buy(price, amount, ...args)

Examples

• The order ID returned by exchange.Buy() can be used to query order information and cancel orders.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      var id = exchange.Buy(100, 1);
      Log("id:", id);
  }
  

  
      python
      
      
  def main():
      id = exchange.Buy(100, 1)
      Log("id:", id)
  

  
      c++
      
      
  void main() {
      auto id = exchange.Buy(100, 1);
      Log("id:", id);
  }
  

• When placing orders for cryptocurrency futures contracts, you must ensure the trading direction is set correctly. If the trading direction does not match the trading function, an error will occur:

  
              log
              
              
  direction is sell, invalid order type Buy
  direction is buy, invalid order type Sell
  direction is closebuy, invalid order type Buy
  direction is closesell, invalid order type Sell
  

  • javascript
  • python
  • cpp

  
      javascript
      
      
  // The following are incorrect calls
  function main() {
      exchange.SetContractType("quarter")
  
      // Set short direction
      exchange.SetDirection("sell")
      // Place buy order, will error, short can only sell
      var id = exchange.Buy(50, 1)
  
      // Set long direction
      exchange.SetDirection("buy")
      // Place sell order, will error, long can only buy
      var id2 = exchange.Sell(60, 1)
  
      // Set close long direction
      exchange.SetDirection("closebuy")
      // Place buy order, will error, close long can only sell
      var id3 = exchange.Buy(-1, 1)
  
      // Set close short direction
      exchange.SetDirection("closesell")
      // Place sell order, will error, close short can only buy
      var id4 = exchange.Sell(-1, 1)
  }
  

  
      python
      
      
  # The following are incorrect calls
  def main():
      exchange.SetContractType("quarter")
      exchange.SetDirection("sell")
      id = exchange.Buy(50, 1)
      exchange.SetDirection("buy")
      id2 = exchange.Sell(60, 1)
      exchange.SetDirection("closebuy")
      id3 = exchange.Buy(-1, 1)
      exchange.SetDirection("closesell")
      id4 = exchange.Sell(-1, 1)
  

  
      c++
      
      
  // The following are incorrect calls
  void main() {
      exchange.SetContractType("quarter");
      exchange.SetDirection("sell");
      auto id = exchange.Buy(50, 1);
      exchange.SetDirection("buy");
      auto id2 = exchange.Sell(60, 1);
      exchange.SetDirection("closebuy");
      auto id3 = exchange.Buy(-1, 1);
      exchange.SetDirection("closesell");
      auto id4 = exchange.Sell(-1, 1);
  }
  

• Spot market order.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  // For example, trading pair: ETH_BTC, market buy order
  function main() {
      // Place market buy order, buy ETH worth 0.1 BTC (quote currency)
      exchange.Buy(-1, 0.1)
  }
  

  
      python
      
      
  def main():
      exchange.Buy(-1, 0.1)
  

  
      c++
      
      
  void main() {
      exchange.Buy(-1, 0.1);
  }
  

Returns

Arguments

See Also

Remarks

When placing orders for futures contracts, you must ensure the trading direction is set correctly. An error will be reported if the trading direction does not match the trading function. Unless otherwise specified, the order quantity for cryptocurrency futures contract exchanges is in number of contracts.

Setting the price parameter to -1 is used to place market orders, which requires the exchange's order interface to support market orders. For cryptocurrency spot market orders, when placing buy orders, the order quantity parameter amount is the amount in quote currency. For cryptocurrency futures contract market orders, the order quantity parameter amount is in number of contracts. In live trading, a few cryptocurrency exchanges do not support market order interfaces. For some spot exchanges, the order quantity for market buy orders is in base currency. Please refer to the Exchange Special Instructions in the "User Guide" for details.

If using an older version of the docker, the return value order Id of the exchange.Buy() function may differ from the return value order Id described in the current documentation.

Note that the following three exchanges have special order interfaces. For spot market buy orders, the order quantity is in coins, not in amount.

• AscendEx

• BitMEX

• Bitfinex

exchange.Sell

The exchange.Sell() function is used to place a sell order.

    
    
    
exchange.Sell(price, amount)

    
    
    
exchange.Sell(price, amount, ...args)

Examples

• The order ID returned by exchange.Sell() can be used to query order information and cancel orders.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main(){
      var id = exchange.Sell(100, 1)
      Log("id:", id)
  }
  

  
      python
      
      
  def main():
      id = exchange.Sell(100, 1)
      Log("id:", id)
  

  
      c++
      
      
  void main() {
      auto id = exchange.Sell(100, 1);
      Log("id:", id);
  }
  

• When placing orders for cryptocurrency futures contracts, you must ensure the trading direction is set correctly. If the trading direction does not match the trading function, an error will occur:

  
              log
              
              
  direction is sell, invalid order type Buy
  direction is buy, invalid order type Sell
  direction is closebuy, invalid order type Buy
  direction is closesell, invalid order type Sell
  

  • javascript
  • python
  • cpp

  
      javascript
      
      
  // The following are incorrect calls
  function main() {
      exchange.SetContractType("quarter")
  
      // Set short direction
      exchange.SetDirection("sell")
      // Place buy order, will error, short can only sell
      var id = exchange.Buy(50, 1)
  
      // Set long direction
      exchange.SetDirection("buy")
      // Place sell order, will error, long can only buy
      var id2 = exchange.Sell(60, 1)
  
      // Set close long direction
      exchange.SetDirection("closebuy")
      // Place buy order, will error, close long can only sell
      var id3 = exchange.Buy(-1, 1)
  
      // Set close short direction
      exchange.SetDirection("closesell")
      // Place sell order, will error, close short can only buy
      var id4 = exchange.Sell(-1, 1)
  }
  

  
      python
      
      
  # The following are incorrect calls
  def main():
      exchange.SetContractType("quarter")
      exchange.SetDirection("sell")
      id = exchange.Buy(50, 1)
      exchange.SetDirection("buy")
      id2 = exchange.Sell(60, 1)
      exchange.SetDirection("closebuy")
      id3 = exchange.Buy(-1, 1)
      exchange.SetDirection("closesell")
      id4 = exchange.Sell(-1, 1)
  

  
      c++
      
      
  // The following are incorrect calls
  void main() {
      exchange.SetContractType("quarter");
      exchange.SetDirection("sell");
      auto id = exchange.Buy(50, 1);
      exchange.SetDirection("buy");
      auto id2 = exchange.Sell(60, 1);
      exchange.SetDirection("closebuy");
      auto id3 = exchange.Buy(-1, 1);
      exchange.SetDirection("closesell");
      auto id4 = exchange.Sell(-1, 1);
  }
  

• Spot market order.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  // For example, trading pair: ETH_BTC, market sell order
  function main() {
      // Note: Place market sell order, sell 0.2 ETH
      exchange.Sell(-1, 0.2)
  }
  

  
      python
      
      
  def main():
      exchange.Sell(-1, 0.2)
  

  
      c++
      
      
  void main() {
      exchange.Sell(-1, 0.2);
  }
  

Returns

Arguments

See Also

Remarks

When placing orders for futures contracts, ensure the trading direction is set correctly. An error will occur if the trading direction does not match the trading function. Unless otherwise specified, the order quantity for cryptocurrency futures contract exchanges is in number of contracts.

Setting the price parameter to -1 places a market order, which requires the exchange's order interface to support market orders. For cryptocurrency spot market orders, when placing a sell order, the order quantity parameter amount is denominated in the trading currency. For cryptocurrency futures contract market orders, the order quantity parameter amount is denominated in number of contracts. In live trading, a few cryptocurrency exchanges do not support market order interfaces.

If using an older version of the docker, the return value order Id from the exchange.Sell() function may differ from the return value order Id described in the current documentation.

exchange.CreateOrder

The exchange.CreateOrder() function is used to place an order.

    
    
    
exchange.CreateOrder(symbol, side, price, amount)

    
    
    
exchange.CreateOrder(symbol, side, price, amount, ...args)

Examples

• Spot exchange objects and futures exchange objects call the exchange.CreateOrder() function to place orders.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      var id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01)           // Spot exchange object places order for BTC_USDT spot trading pair
      // var id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01)   // Futures exchange object places order for BTC USDT-margined perpetual contract
      Log("Order Id:", id)
  }
  

  
      python
      
      
  def main():
      id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01)          # Spot exchange object places order for BTC_USDT spot trading pair
      # id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01)   # Futures exchange object places order for BTC USDT-margined perpetual contract
      Log("Order Id:", id)
  

  
      c++
      
      
  void main() {
      auto id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01);           // Spot exchange object places order for BTC_USDT spot trading pair
      // auto id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01);   // Futures exchange object places order for BTC USDT-margined perpetual contract
      Log("Order Id:", id);
  }
  

• Place orders using additional parameters (option) to pass exchange-specific parameters.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Pass option parameter in JSON format
      var option = {
          "type": "TRAILING_STOP_MARKET",
          "activationPrice": "2300",
          "callbackRate": "0.1"
      }
      var sideWithOption = "buy;" + JSON.stringify(option)
      var id = exchange.CreateOrder("SOL_USDT.swap", sideWithOption, -1, 1)
      Log("Order Id:", id)
  
      Sleep(2000)
      Log(exchange.GetOrder(id))
  }
  

  
      python
      
      
  import json
  
  def main():
      # Pass option parameter in JSON format
      option = {
          "type": "TRAILING_STOP_MARKET",
          "activationPrice": "2300",
          "callbackRate": "0.1"
      }
      sideWithOption = "buy;" + json.dumps(option)
      id = exchange.CreateOrder("SOL_USDT.swap", sideWithOption, -1, 1)
      Log("Order Id:", id)
  
      Sleep(2000)
      Log(exchange.GetOrder(id))
  

  
      c++
      
      
  void main() {
      // Pass option parameter in JSON format
      json option = R"({
          "type": "TRAILING_STOP_MARKET",
          "activationPrice": "2300",
          "callbackRate": "0.1"
      })"_json;
      string sideWithOption = "buy;" + option.dump();
      auto id = exchange.CreateOrder("SOL_USDT.swap", sideWithOption, -1, 1);
      Log("Order Id:", id);
  
      Sleep(2000);
      Log(exchange.GetOrder(id));
  }
  

Returns

Arguments

See Also

Remarks

Supports passing additional parameters (option) through the side parameter to pass exchange-specific parameters. The additional parameters need to be merged with the side parameter in the format "side;{JSON object}" (recommended) or "side;key=value&key=value" (URL-encoded format). For example: "buy;{\"type\":\"TRAILING_STOP_MARKET\"}".

Different exchanges support different option parameters. Please refer to the exchange API documentation for specific supported parameters. Common parameters include: order type (type), time in force (timeInForce), activation price (activationPrice), callback rate (callbackRate), etc.

When using the option parameter, the price and amount parameters still need to be provided. If certain parameters in the exchange API have already been passed through option, these basic parameters may be overridden by the corresponding parameters in option. The specific behavior depends on the exchange API implementation.

exchange.CancelOrder

The exchange.CancelOrder() function is used to cancel an order. The Id attribute of the FMZ platform's order Order structure consists of the exchange product code and the exchange's original order ID, separated by an English comma. For example, the Id attribute format for an order of the spot trading pair ETH_USDT on the OKX exchange is: ETH-USDT,1547130415509278720.

When calling the exchange.CancelOrder() function to cancel an order, the orderId parameter passed in should be consistent with the Id attribute of the order Order structure.

    
    
    
exchange.CancelOrder(orderId)

    
    
    
exchange.CancelOrder(orderId, ...args)

Examples

• Cancel an order.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main(){
      var id = exchange.Sell(99999, 1)
      exchange.CancelOrder(id)
  }
  

  
      python
      
      
  def main():
      id = exchange.Sell(99999, 1)
      exchange.CancelOrder(id)
  

  
      c++
      
      
  void main() {
      auto id = exchange.Sell(99999, 1);
      exchange.CancelOrder(id);
  }
  

• In FMZ's API functions that can generate log output, such as Log(), exchange.Buy(), exchange.CancelOrder(), etc., additional output parameters can be appended after the required parameters. For example: exchange.CancelOrder(orders[i].Id, orders[i]), this way when canceling the order with Id orders[i].Id, it will also output the order information, i.e., the Order structure orders[i].

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      if (exchange.GetName().includes("Futures_")) {
          Log("Set contract to: perpetual swap, set direction to: open long.")
          exchange.SetContractType("swap")
          exchange.SetDirection("buy")
      }
  
      var ticker = exchange.GetTicker()
      exchange.Buy(ticker.Last * 0.5, 0.1)
  
      var orders = exchange.GetOrders()
      for (var i = 0 ; i < orders.length ; i++) {
          exchange.CancelOrder(orders[i].Id, "Canceled order:", orders[i])
          Sleep(500)
      }
  }
  

  
      python
      
      
  def main():
      if exchange.GetName().find("Futures_") != -1:
          Log("Set contract to: perpetual swap, set direction to: open long.")
          exchange.SetContractType("swap")
          exchange.SetDirection("buy")
  
      ticker = exchange.GetTicker()
      exchange.Buy(ticker["Last"] * 0.5, 0.1)
  
      orders = exchange.GetOrders()
      for i in range(len(orders)):
          exchange.CancelOrder(orders[i]["Id"], "Canceled order:", orders[i])
          Sleep(500)
  

  
      c++
      
      
  void main() {
      if (exchange.GetName().find("Futures_") != std::string::npos) {
          Log("Set contract to: perpetual swap, set direction to: open long.");
          exchange.SetContractType("swap");
          exchange.SetDirection("buy");
      }
  
      auto ticker = exchange.GetTicker();
      exchange.Buy(ticker.Last * 0.5, 0.1);
  
      auto orders = exchange.GetOrders();
      for (int i = 0 ; i < orders.size() ; i++) {
          exchange.CancelOrder(orders[i].Id, "Canceled order:", orders[i]);
          Sleep(500);
      }
  }
  

Returns

Arguments

See Also

Remarks

If using an older version of the docker, the orderId parameter of the exchange.CancelOrder() function may differ from the orderId described in the current documentation.

exchange.GetOrder

The exchange.GetOrder() function is used to get order information.

    
    
    
exchange.GetOrder(orderId)

Examples

    javascript
    
    
function main(){
    var id = exchange.Sell(1000, 1)
    // The parameter id is the order number, you need to fill in the order number you want to query
    var order = exchange.GetOrder(id)
    Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:",
        order.DealAmount, "Status:", order.Status, "Type:", order.Type)
}

    python
    
    
def main():
    id = exchange.Sell(1000, 1)
    order = exchange.GetOrder(id)
    Log("Id:", order["Id"], "Price:", order["Price"], "Amount:", order["Amount"], "DealAmount:",
        order["DealAmount"], "Status:", order["Status"], "Type:", order["Type"])

    c++
    
    
void main() {
    auto id = exchange.Sell(1000, 1);
    auto order = exchange.GetOrder(id);
    Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:",
        order.DealAmount, "Status:", order.Status, "Type:", order.Type);
}

Returns

Arguments

See Also

Remarks

Some exchanges do not support the exchange.GetOrder() function. The AvgPrice attribute in the returned Order structure is the average execution price. Some exchanges do not support this field, and it is set to 0 when not supported.

If using an older version of the docker, the orderId parameter of the exchange.GetOrder() function may differ from the orderId described in the current documentation.

Exchanges that do not support the exchange.GetOrder() function:

exchange.GetOrders

The exchange.GetOrders() function is used to get unfilled orders.

    
    
    
exchange.GetOrders()

    
    
    
exchange.GetOrders(symbol)

Examples

• Using spot exchange objects to operate on multiple different trading pairs, placing buy orders at half the current price, then querying pending order information.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  /*backtest
  start: 2024-05-21 00:00:00
  end: 2024-09-05 00:00:00
  period: 5m
  basePeriod: 1m
  exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
  */
  
  function main() {
      var arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]
  
      for (var symbol of arrSymbol) {
          var t = exchange.GetTicker(symbol)
          exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01)
      }
  
      var spotOrders = exchange.GetOrders()
  
      var tbls = []
      for (var orders of [spotOrders]) {
          var tbl = {type: "table", title: "test GetOrders", cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
          for (var order of orders) {
              tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
          }
          tbls.push(tbl)
      }
  
      LogStatus("`" + JSON.stringify(tbls) +  "`")
  
      // 打印输出一次信息后返回，防止后续回测时订单成交，影响数据观察
      return
  }
  

  
      python
      
      
  '''backtest
  start: 2024-05-21 00:00:00
  end: 2024-09-05 00:00:00
  period: 5m
  basePeriod: 1m
  exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
  '''
  
  import json
  
  def main():
      arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]
  
      for symbol in arrSymbol:
          t = exchange.GetTicker(symbol)
          exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 0.01)
  
      spotOrders = exchange.GetOrders()
  
      tbls = []
      for orders in [spotOrders]:
          tbl = {"type": "table", "title": "test GetOrders", "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
          for order in orders:
              tbl["rows"].append([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
          tbls.append(tbl)
  
      LogStatus("`" + json.dumps(tbls) +  "`")
  
      return
  

  
      c++
      
      
  /*backtest
  start: 2024-05-21 00:00:00
  end: 2024-09-05 00:00:00
  period: 5m
  basePeriod: 1m
  exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
  */
  
  void main() {
      auto arrSymbol = {"ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"};
  
      for (const auto& symbol : arrSymbol) {
          auto t = exchange.GetTicker(symbol);
          exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01);
      }
  
      auto spotOrders = exchange.GetOrders();
  
      json tbls = R"([])"_json;
      std::vector<std::vector<Order>> arr = {spotOrders};
      for (const auto& orders : arr) {
          json tbl = R"({
              "type": "table",
              "title": "test GetOrders",
              "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
              "rows": []
          })"_json;
  
          for (const auto& order : orders) {
              json arrJson = R"([])"_json;
  
              arrJson.push_back("Symbol");
              arrJson.push_back("Id");
              arrJson.push_back(order.Price);
              arrJson.push_back(order.Amount);
              arrJson.push_back(order.DealAmount);
              arrJson.push_back(order.AvgPrice);
              arrJson.push_back(order.Status);
              arrJson.push_back(order.Type);
              arrJson.push_back(order.Offset);
              arrJson.push_back(order.ContractType);
  
              tbl["rows"].push_back(arrJson);
          }
  
          tbls.push_back(tbl);
      }
  
      LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
  
      return;
  }
  

• Use futures exchange object to place orders for multiple trading pairs and contract codes. Set order prices far from the order book counterparty prices to keep orders in unfilled status, and query orders in various ways.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  /*backtest
  start: 2024-05-21 00:00:00
  end: 2024-09-05 00:00:00
  period: 5m
  basePeriod: 1m
  exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
  */
  
  function main() {
      var arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
  
      for (var symbol of arrSymbol) {
          var t = exchange.GetTicker(symbol)
          exchange.CreateOrder(symbol, "buy", t.Last / 2, 1)
          exchange.CreateOrder(symbol, "sell", t.Last * 2, 1)
      }
  
      var defaultOrders = exchange.GetOrders()
      var swapOrders = exchange.GetOrders("USDT.swap")
      var futuresOrders = exchange.GetOrders("USDT.futures")
      var btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")
  
      var tbls = []
      var arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
      var tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
      for (var index in arr) {
          var orders = arr[index]
          var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
          for (var order of orders) {
              tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
          }
          tbls.push(tbl)
      }
  
      LogStatus("`" + JSON.stringify(tbls) +  "`")
  
      // 打印输出一次信息后返回，防止后续回测时订单成交，影响数据观察
      return
  }
  

  
      python
      
      
  '''backtest
  start: 2024-05-21 00:00:00
  end: 2024-09-05 00:00:00
  period: 5m
  basePeriod: 1m
  exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
  '''
  
  import json
  
  def main():
      arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
  
      for symbol in arrSymbol:
          t = exchange.GetTicker(symbol)
          exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 1)
          exchange.CreateOrder(symbol, "sell", t["Last"] * 2, 1)
  
      defaultOrders = exchange.GetOrders()
      swapOrders = exchange.GetOrders("USDT.swap")
      futuresOrders = exchange.GetOrders("USDT.futures")
      btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")
  
      tbls = []
      arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
      tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
      for index in range(len(arr)):
          orders = arr[index]
          tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
          for order in orders:
              tbl["rows"].append([order["Symbol"], order["Id"], order["Price"], order["Amount"], order["DealAmount"], order["AvgPrice"], order["Status"], order["Type"], order["Offset"], order["ContractType"]])
          tbls.append(tbl)
  
      LogStatus("`" + json.dumps(tbls) +  "`")
  
      return
  

  
      c++
      
      
  /*backtest
  start: 2024-05-21 00:00:00
  end: 2024-09-05 00:00:00
  period: 5m
  basePeriod: 1m
  exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
  */
  
  void main() {
      auto arrSymbol = {"BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
  
      for (const auto& symbol : arrSymbol) {
          auto t = exchange.GetTicker(symbol);
          exchange.CreateOrder(symbol, "buy", t.Last / 2, 1);
          exchange.CreateOrder(symbol, "sell", t.Last * 2, 1);
      }
  
      auto defaultOrders = exchange.GetOrders();
      auto swapOrders = exchange.GetOrders("USDT.swap");
      auto futuresOrders = exchange.GetOrders("USDT.futures");
      auto btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap");
  
      json tbls = R"([])"_json;
      std::vector<std::vector<Order>> arr = {defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders};
      std::string tblDesc[] = {"defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"};
      for (int index = 0; index < arr.size(); index++) {
          auto orders = arr[index];
          json tbl = R"({
              "type": "table",
              "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
              "rows": []
          })"_json;
          tbl["title"] = tblDesc[index];
  
          for (const auto& order : orders) {
              json arrJson = R"([])"_json;
  
              arrJson.push_back(order.Symbol);
              arrJson.push_back(to_string(order.Id));    // Order订单结构中的Id属性类型为TId，使用FMZ平台内置的C++函数to_string进行编码
              arrJson.push_back(order.Price);
              arrJson.push_back(order.Amount);
              arrJson.push_back(order.DealAmount);
              arrJson.push_back(order.AvgPrice);
              arrJson.push_back(order.Status);
              arrJson.push_back(order.Type);
              arrJson.push_back(order.Offset);
              arrJson.push_back(order.ContractType);
  
              tbl["rows"].push_back(arrJson);
          }
  
          tbls.push_back(tbl);
      }
  
      LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
  
      return;
  }
  

• When calling the exchange.GetOrders() function, pass the Symbol parameter to specify the order data for the trading pair or contract code to be queried.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      var orders = exchange.GetOrders("BTC_USDT")          // 现货品种举例
      // var orders = exchange.GetOrders("BTC_USDT.swap")   // 期货品种举例
      Log("orders:", orders)
  }
  

  
      python
      
      
  def main():
      orders = exchange.GetOrders("BTC_USDT")          # 现货品种举例
      # orders = exchange.GetOrders("BTC_USDT.swap")   # 期货品种举例
      Log("orders:", orders)
  

  
      c++
      
      
  void main() {
      auto orders = exchange.GetOrders("BTC_USDT");          // 现货品种举例
      // auto orders = exchange.GetOrders("BTC_USDT.swap");   // 期货品种举例
      Log("orders:", orders);
  }
  

Returns

Arguments

See Also

Remarks

Summary of symbol parameter usage scenarios in the GetOrders function:

Summary of futures exchange object query dimension ranges in the GetOrders function:

When the account represented by the exchange object exchange has no pending orders (active orders in unfilled status) within the query scope or specified trading variety, calling this function returns an empty array, i.e.: [].

The following exchanges require a symbol parameter when querying current unfilled orders. When calling the GetOrders function with these exchanges, if no symbol parameter is passed, only the unfilled orders of the current variety are requested, not all varieties' unfilled orders (because the exchange API does not support it).

Zaif, MEXC, LBank, Korbit, Coinw, BitMart, Bithumb, BitFlyer, BigONE.

Exchanges that do not support the exchange.GetOrders() function:

exchange.GetHistoryOrders

The exchange.GetHistoryOrders() function is used to get historical orders for the current trading pair or contract, and supports specifying specific trading instruments.

    
    
    
exchange.GetHistoryOrders()

    
    
    
exchange.GetHistoryOrders(symbol)

    
    
    
exchange.GetHistoryOrders(symbol, since)

    
    
    
exchange.GetHistoryOrders(symbol, since, limit)

    
    
    
exchange.GetHistoryOrders(since)

    
    
    
exchange.GetHistoryOrders(since, limit)

Examples

    javascript
    
    
function main() {
    var historyOrders = exchange.GetHistoryOrders()
    Log(historyOrders)
}

    python
    
    
def main():
    historyOrders = exchange.GetHistoryOrders()
    Log(historyOrders)

    c++
    
    
void main() {
    auto historyOrders = exchange.GetHistoryOrders();
    Log(historyOrders);
}

Returns

Arguments

See Also

Remarks

• When symbol, since, and limit parameters are not specified, it defaults to querying historical orders for the current trading pair or contract. It queries historical orders within a certain range closest to the current time, with the query range determined by the single query range of the exchange API.

• When the symbol parameter is specified, it queries historical orders for the specified trading instrument.

• When the since parameter is specified, it queries from the since timestamp towards the current time.

• When the limit parameter is specified, it returns after querying the sufficient number of entries.

• This function only supports exchanges that provide historical order query interfaces.

Exchanges that do not support the exchange.GetHistoryOrders() function:

exchange.CreateConditionOrder

exchange.CreateConditionOrder() function is used to create a conditional order. A conditional order is an order type that automatically executes when specific trigger conditions are met.

    
    
    
exchange.CreateConditionOrder(symbol, side, amount, condition)

    
    
    
exchange.CreateConditionOrder(symbol, side, amount, condition, ...args)

Examples

• Create a Take Profit order (TP): Automatically sell when the price rises to the target price.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Create TP order: When BTC_USDT price rises to 65000, sell 0.01 BTC at price 65000
      var condition = {
          ConditionType: ORDER_CONDITION_TYPE_TP,  // Take Profit order
          TpTriggerPrice: 65000,   // Trigger price
          TpOrderPrice: 65000      // Execution price, can also be set to -1 for market order
      }
      var id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Log("TP order Id:", id)
  }
  

  
      python
      
      
  def main():
      # Create TP order: When BTC_USDT price rises to 65000, sell 0.01 BTC at price 65000
      condition = {
          "ConditionType": ORDER_CONDITION_TYPE_TP,  # Take Profit order
          "TpTriggerPrice": 65000,   # Trigger price
          "TpOrderPrice": 65000      # Execution price, can also be set to -1 for market order
      }
      id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Log("TP order Id:", id)
  

  
      c++
      
      
  void main() {
      // Create TP order: When BTC_USDT price rises to 65000, sell 0.01 BTC at price 65000
      OrderCondition condition = {.ConditionType = ORDER_CONDITION_TYPE_TP, .TpTriggerPrice = 65000, .TpOrderPrice = 65000};
      auto id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition);
      Log("TP order Id:", id);
  }
  

• Create a Stop Loss order (SL): Automatically sell when the price drops to the stop loss price.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Create SL order: When BTC_USDT price drops to 58000, sell 0.01 BTC at market price
      var condition = {
          ConditionType: ORDER_CONDITION_TYPE_SL,  // Stop Loss order
          SlTriggerPrice: 58000,   // Trigger price
          SlOrderPrice: -1         // -1 means market order
      }
      var id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Log("SL order Id:", id)
  }
  

  
      python
      
      
  def main():
      # Create SL order: When BTC_USDT price drops to 58000, sell 0.01 BTC at market price
      condition = {
          "ConditionType": ORDER_CONDITION_TYPE_SL,  # Stop Loss order
          "SlTriggerPrice": 58000,   # Trigger price
          "SlOrderPrice": -1         # -1 means market order
      }
      id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Log("SL order Id:", id)
  

  
      c++
      
      
  void main() {
      // Create SL order: When BTC_USDT price drops to 58000, sell 0.01 BTC at market price
      OrderCondition condition = {.ConditionType = ORDER_CONDITION_TYPE_SL, .SlTriggerPrice = 58000, .SlOrderPrice = -1};
      auto id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition);
      Log("SL order Id:", id);
  }
  

• Create OCO order: Set take-profit and stop-loss simultaneously. When either one is triggered, the other is automatically canceled.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Create OCO order: take-profit price 65000, stop-loss price 58000
      var condition = {
          ConditionType: ORDER_CONDITION_TYPE_OCO,  // OCO order
          TpTriggerPrice: 65000,   // Take-profit trigger price
          TpOrderPrice: 65000,     // Take-profit execution price
          SlTriggerPrice: 58000,   // Stop-loss trigger price
          SlOrderPrice: 58000      // Stop-loss execution price
      }
      var id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Log("OCO order Id:", id)
  }
  

  
      python
      
      
  def main():
      # Create OCO order: take-profit price 65000, stop-loss price 58000
      condition = {
          "ConditionType": ORDER_CONDITION_TYPE_OCO,  # OCO order
          "TpTriggerPrice": 65000,   # Take-profit trigger price
          "TpOrderPrice": 65000,     # Take-profit execution price
          "SlTriggerPrice": 58000,   # Stop-loss trigger price
          "SlOrderPrice": 58000      # Stop-loss execution price
      }
      id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Log("OCO order Id:", id)
  

  
      c++
      
      
  void main() {
      // Create OCO order: take-profit price 65000, stop-loss price 58000
      OrderCondition condition = {.ConditionType = ORDER_CONDITION_TYPE_OCO, .TpTriggerPrice = 65000, .TpOrderPrice = 65000, .SlTriggerPrice = 58000, .SlOrderPrice = 58000};
      auto id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition);
      Log("OCO order Id:", id);
  }
  

• Create a condition order using additional parameters (option) to pass exchange-specific parameters.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Pass option parameter using JSON format
      var option = {
          "type": "TRAILING_STOP_MARKET",
          "activatePrice": "300",
          "callbackRate": "0.1"
      }
      var sideWithOption = "buy;" + JSON.stringify(option)
      var condition = {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 77,
          TpOrderPrice: 71
      }
      var id = exchange.CreateConditionOrder("SOL_USDT.swap", sideWithOption, 1, condition)
      Log("Condition Order Id:", id)
  
      Sleep(2000)
      Log(exchange.GetConditionOrder(id))
  }
  

  
      python
      
      
  import json
  
  def main():
      # Pass option parameter using JSON format
      option = {
          "type": "TRAILING_STOP_MARKET",
          "activatePrice": "300",
          "callbackRate": "0.1"
      }
      sideWithOption = "buy;" + json.dumps(option)
      condition = {
          "ConditionType": ORDER_CONDITION_TYPE_TP,
          "TpTriggerPrice": 77,
          "TpOrderPrice": 71
      }
      id = exchange.CreateConditionOrder("SOL_USDT.swap", sideWithOption, 1, condition)
      Log("Condition Order Id:", id)
  
      Sleep(2000)
      Log(exchange.GetConditionOrder(id))
  

  
      c++
      
      
  void main() {
      // Pass option parameter using JSON format
      json option = R"({
          "type": "TRAILING_STOP_MARKET",
          "activatePrice": "300",
          "callbackRate": "0.1"
      })"_json;
      string sideWithOption = "buy;" + option.dump();
      OrderCondition condition = {.ConditionType = ORDER_CONDITION_TYPE_TP, .TpTriggerPrice = 77, .TpOrderPrice = 71};
      auto id = exchange.CreateConditionOrder("SOL_USDT.swap", sideWithOption, 1, condition);
      Log("Condition Order Id:", id);
  
      Sleep(2000);
      Log(exchange.GetConditionOrder(id));
  }
  

Returns

Arguments

See Also

Remarks

Support for conditional orders depends on the specific exchange; some exchanges may not support conditional order functionality.

Conditional orders do not occupy account funds before being triggered; funds are only occupied when the order is actually placed after triggering.

Different exchanges may have varying levels of support and specific parameters for conditional orders. Please refer to the corresponding exchange's API documentation before use.

Supports passing additional parameters (option) through the side parameter for exchange-specific parameters. Additional parameters need to be merged with the side parameter in the format "side;{JSON object}" (recommended) or "side;key=value&key=value" (URL encoded format). For example: "buy;{\"type\":\"TRAILING_STOP_MARKET\"}".

Different exchanges support different option parameters; the specific supported parameters depend on the exchange's API documentation. Common parameters include: order type (type), time in force (timeInForce), activation price (activatePrice), callback rate (callbackRate), etc.

When using option parameters, the amount and condition parameters still need to be provided. If certain parameters in the exchange API have been passed through option, these basic parameters may be overridden by the corresponding parameters in option; the specific behavior depends on the exchange API implementation.

exchange.ModifyOrder

The exchange.ModifyOrder() function is used to modify existing regular orders, allowing modification of order price and quantity. Supports modifying other order attributes through additional parameters (depending on exchange API support).

    
    
    
exchange.ModifyOrder(orderId, side, price, amount)

Examples

• Modify the price and quantity of a regular order.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Create a limit buy order
      var id = exchange.CreateOrder("SOL_USDT.swap", "buy", 88, 1)
      Log("Original Order ID:", id)
      Sleep(2000)
  
      // Query original order information
      var order = exchange.GetOrder(id)
      Log("Original Order Info:", order)
      Sleep(1000)
  
      // Modify order price and quantity
      var newId = exchange.ModifyOrder(id, "buy", 77, 2)
      Log("Modified Order ID:", newId)
      Sleep(2000)
  
      // Query modified order information
      var newOrder = exchange.GetOrder(newId)
      Log("Modified Order Info:", newOrder)
  
      // Cancel order
      exchange.CancelOrder(newId)
  }
  

  
      python
      
      
  def main():
      # Create a limit buy order
      id = exchange.CreateOrder("SOL_USDT.swap", "buy", 88, 1)
      Log("Original Order ID:", id)
      Sleep(2000)
  
      # Query original order information
      order = exchange.GetOrder(id)
      Log("Original Order Info:", order)
      Sleep(1000)
  
      # Modify order price and quantity
      newId = exchange.ModifyOrder(id, "buy", 77, 2)
      Log("Modified Order ID:", newId)
      Sleep(2000)
  
      # Query modified order information
      newOrder = exchange.GetOrder(newId)
      Log("Modified Order Info:", newOrder)
  
      # Cancel order
      exchange.CancelOrder(newId)
  

  
      c++
      
      
  void main() {
      // Create a limit buy order
      auto id = exchange.CreateOrder("SOL_USDT.swap", "buy", 88, 1);
      Log("Original Order ID:", id);
      Sleep(2000);
  
      // Query original order information
      auto order = exchange.GetOrder(id);
      Log("Original Order Info:", order);
      Sleep(1000);
  
      // Modify order price and quantity
      auto newId = exchange.ModifyOrder(id, "buy", 77, 2);
      Log("Modified Order ID:", newId);
      Sleep(2000);
  
      // Query modified order information
      auto newOrder = exchange.GetOrder(newId);
      Log("Modified Order Info:", newOrder);
  
      // Cancel order
      exchange.CancelOrder(newId);
  }
  

• Use additional parameters (option) to modify the order's price matching mode.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Create a limit buy order
      var id = exchange.CreateOrder("SOL_USDT.swap", "buy", 77, 1)
      Log("Original Order ID:", id)
      Sleep(2000)
  
      // Modify order and set price matching mode to QUEUE_20
      // Pass additional parameters (JSON format) through side parameter
      var option = {"priceMatch": "QUEUE_20"}
      var sideWithOption = "buy;" + JSON.stringify(option)
  
      var newId = exchange.ModifyOrder(id, sideWithOption, -1, 2)
      Log("Modified Order ID:", newId)
      Sleep(2000)
  
      // Query modified order information
      var newOrder = exchange.GetOrder(newId)
      Log("Modified Order Info:", newOrder)
  
      // Cancel order
      exchange.CancelOrder(newId)
  }
  

  
      python
      
      
  import json
  
  def main():
      # Create a limit buy order
      id = exchange.CreateOrder("SOL_USDT.swap", "buy", 77, 1)
      Log("Original Order ID:", id)
      Sleep(2000)
  
      # Modify order and set price matching mode to QUEUE_20
      # Pass additional parameters (JSON format) through side parameter
      option = {"priceMatch": "QUEUE_20"}
      sideWithOption = "buy;" + json.dumps(option)
  
      newId = exchange.ModifyOrder(id, sideWithOption, -1, 2)
      Log("Modified Order ID:", newId)
      Sleep(2000)
  
      # Query modified order information
      newOrder = exchange.GetOrder(newId)
      Log("Modified Order Info:", newOrder)
  
      # Cancel order
      exchange.CancelOrder(newId)
  

  
      c++
      
      
  void main() {
      // Create a limit buy order
      auto id = exchange.CreateOrder("SOL_USDT.swap", "buy", 77, 1);
      Log("Original Order ID:", id);
      Sleep(2000);
  
      // Modify order and set price matching mode to QUEUE_20
      // Pass additional parameters (JSON format) through side parameter
      json option = R"({"priceMatch": "QUEUE_20"})"_json;
      string sideWithOption = "buy;" + option.dump();
  
      auto newId = exchange.ModifyOrder(id, sideWithOption, -1, 2);
      Log("Modified Order ID:", newId);
      Sleep(2000);
  
      // Query modified order information
      auto newOrder = exchange.GetOrder(newId);
      Log("Modified Order Info:", newOrder);
  
      // Cancel order
      exchange.CancelOrder(newId);
  }
  

Returns

Arguments

See Also

Remarks

The order ID returned by the exchange.ModifyOrder() function may behave differently depending on the exchange API implementation. Some exchange APIs will update the returned order ID, while others keep it unchanged. It is recommended to use the returned new order ID for subsequent operations.

The exchange.ModifyOrder() function does not validate parameter validity according to exchange interface rules and will submit parameters directly to the exchange API. When invalid parameters are passed (such as price or quantity being -1), the parameters may be ignored by the exchange, and the order maintains its original attributes unchanged.

Supports passing additional parameters (option) through the side parameter to modify other order attributes. Additional parameters need to be merged with the side parameter in the format "side;{JSON object}" (recommended) or "side;key=value" (URL encoding format). For example, to modify price matching mode: "buy;{\"priceMatch\":\"QUEUE_20\"}".

For market order modification of regular orders, you need to check specifically whether the exchange API supports it. Some exchanges do not support market order modification operations.

When modifying orders, other order attributes (such as order type, position mode, account mode, leverage, order validity rules, etc.) usually retain the original order settings. If you need to modify these attributes, you can pass them through additional parameters (option), provided the exchange API supports it.

Some exchange APIs may convert orders to market orders when price parameters are not received (price is -1 or null). For spot market buy orders, note that the order quantity unit may be amount rather than coin quantity.

Support for order modification functionality depends on the specific exchange. Some exchanges may not support order modification functionality or only support modification of certain parameters. Please consult the corresponding exchange's API documentation before use.

exchange.ModifyConditionOrder

The exchange.ModifyConditionOrder() function is used to modify an existing conditional order, allowing modification of the order quantity, trigger conditions, and execution price. It supports modifying other attributes of the conditional order through additional parameters (depending on exchange API support).

    
    
    
exchange.ModifyConditionOrder(orderId, side, amount, condition)

Examples

• Modify the quantity and trigger conditions of a conditional order.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Create a take-profit conditional order
      var condition = {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 77,
          TpOrderPrice: 76
      }
      var id = exchange.CreateConditionOrder("SOL_USDT.swap", "buy", 1, condition)
      Log("Original Condition Order ID:", id)
      Sleep(2000)
  
      // Query original conditional order info
      var order = exchange.GetConditionOrder(id)
      Log("Original Condition Order Info:", order)
      Sleep(1000)
  
      // Modify the quantity and trigger conditions of the conditional order
      var newCondition = {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 75,
          TpOrderPrice: 71
      }
      var newId = exchange.ModifyConditionOrder(id, "buy", 2, newCondition)
      Log("Modified Condition Order ID:", newId)
      Sleep(2000)
  
      // Query modified conditional order info
      var newOrder = exchange.GetConditionOrder(newId)
      Log("Modified Condition Order Info:", newOrder)
  
      // Cancel the conditional order
      exchange.CancelConditionOrder(newId)
  }
  

  
      python
      
      
  def main():
      # Create a take-profit conditional order
      condition = {
          "ConditionType": ORDER_CONDITION_TYPE_TP,
          "TpTriggerPrice": 77,
          "TpOrderPrice": 76
      }
      id = exchange.CreateConditionOrder("SOL_USDT.swap", "buy", 1, condition)
      Log("Original Condition Order ID:", id)
      Sleep(2000)
  
      # Query original conditional order info
      order = exchange.GetConditionOrder(id)
      Log("Original Condition Order Info:", order)
      Sleep(1000)
  
      # Modify the quantity and trigger conditions of the conditional order
      newCondition = {
          "ConditionType": ORDER_CONDITION_TYPE_TP,
          "TpTriggerPrice": 75,
          "TpOrderPrice": 71
      }
      newId = exchange.ModifyConditionOrder(id, "buy", 2, newCondition)
      Log("Modified Condition Order ID:", newId)
      Sleep(2000)
  
      # Query modified conditional order info
      newOrder = exchange.GetConditionOrder(newId)
      Log("Modified Condition Order Info:", newOrder)
  
      # Cancel the conditional order
      exchange.CancelConditionOrder(newId)
  

  
      c++
      
      
  void main() {
      // Create a take-profit conditional order
      OrderCondition condition = {.ConditionType = ORDER_CONDITION_TYPE_TP, .TpTriggerPrice = 77, .TpOrderPrice = 76};
      auto id = exchange.CreateConditionOrder("SOL_USDT.swap", "buy", 1, condition);
      Log("Original Condition Order ID:", id);
      Sleep(2000);
  
      // Query original conditional order info
      auto order = exchange.GetConditionOrder(id);
      Log("Original Condition Order Info:", order);
      Sleep(1000);
  
      // Modify the quantity and trigger conditions of the conditional order
      OrderCondition newCondition = {.ConditionType = ORDER_CONDITION_TYPE_TP, .TpTriggerPrice = 75, .TpOrderPrice = 71};
      auto newId = exchange.ModifyConditionOrder(id, "buy", 2, newCondition);
      Log("Modified Condition Order ID:", newId);
      Sleep(2000);
  
      // Query modified conditional order info
      auto newOrder = exchange.GetConditionOrder(newId);
      Log("Modified Condition Order Info:", newOrder);
  
      // Cancel the conditional order
      exchange.CancelConditionOrder(newId);
  }
  

• Use additional parameters (option) to modify the trigger price type of a conditional order.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Create a take-profit conditional order
      var condition = {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 77,
          TpOrderPrice: 76
      }
      var id = exchange.CreateConditionOrder("SOL_USDT.swap", "buy", 1, condition)
      Log("Original Condition Order ID:", id)
      Sleep(2000)
  
      // Modify the conditional order and set the trigger price type to index price
      // Pass additional parameters (JSON format) through the side parameter
      var option = {"newTpTriggerPxType": "index"}
      var sideWithOption = "buy;" + JSON.stringify(option)
  
      var newCondition = {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 75,
          TpOrderPrice: 71
      }
      var newId = exchange.ModifyConditionOrder(id, sideWithOption, 2, newCondition)
      Log("Modified Condition Order ID:", newId)
      Sleep(2000)
  
      // Query the modified conditional order information
      var newOrder = exchange.GetConditionOrder(newId)
      Log("Modified Condition Order Info:", newOrder)
  
      // Cancel the conditional order
      exchange.CancelConditionOrder(newId)
  }
  

  
      python
      
      
  import json
  
  def main():
      # Create a take-profit conditional order
      condition = {
          "ConditionType": ORDER_CONDITION_TYPE_TP,
          "TpTriggerPrice": 77,
          "TpOrderPrice": 76
      }
      id = exchange.CreateConditionOrder("SOL_USDT.swap", "buy", 1, condition)
      Log("Original Condition Order ID:", id)
      Sleep(2000)
  
      # Modify the conditional order and set the trigger price type to index price
      # Pass additional parameters (JSON format) through the side parameter
      option = {"newTpTriggerPxType": "index"}
      sideWithOption = "buy;" + json.dumps(option)
  
      newCondition = {
          "ConditionType": ORDER_CONDITION_TYPE_TP,
          "TpTriggerPrice": 75,
          "TpOrderPrice": 71
      }
      newId = exchange.ModifyConditionOrder(id, sideWithOption, 2, newCondition)
      Log("Modified Condition Order ID:", newId)
      Sleep(2000)
  
      # Query the modified conditional order information
      newOrder = exchange.GetConditionOrder(newId)
      Log("Modified Condition Order Info:", newOrder)
  
      # Cancel the conditional order
      exchange.CancelConditionOrder(newId)
  

  
      c++
      
      
  void main() {
      // Create a take-profit conditional order
      OrderCondition condition = {.ConditionType = ORDER_CONDITION_TYPE_TP, .TpTriggerPrice = 77, .TpOrderPrice = 76};
      auto id = exchange.CreateConditionOrder("SOL_USDT.swap", "buy", 1, condition);
      Log("Original Condition Order ID:", id);
      Sleep(2000);
  
      // Modify the conditional order and set the trigger price type to index price
      // Pass additional parameters (JSON format) through the side parameter
      json option = R"({"newTpTriggerPxType": "index"})"_json;
      string sideWithOption = "buy;" + option.dump();
  
      OrderCondition newCondition = {.ConditionType = ORDER_CONDITION_TYPE_TP, .TpTriggerPrice = 75, .TpOrderPrice = 71};
      auto newId = exchange.ModifyConditionOrder(id, sideWithOption, 2, newCondition);
      Log("Modified Condition Order ID:", newId);
      Sleep(2000);
  
      // Query the modified conditional order information
      auto newOrder = exchange.GetConditionOrder(newId);
      Log("Modified Condition Order Info:", newOrder);
  
      // Cancel the conditional order
      exchange.CancelConditionOrder(newId);
  }
  

Returns

Arguments

See Also

Remarks

The conditional order ID returned by the exchange.ModifyConditionOrder() function may behave differently depending on the exchange API implementation. Some exchange APIs return an updated conditional order ID, while others keep it unchanged. It is recommended to use the returned new conditional order ID for subsequent operations.

The exchange.ModifyConditionOrder() function does not validate parameter validity according to exchange interface rules, but submits parameters directly to the exchange API. When invalid parameters are passed (such as quantity of -1), the parameters may be ignored by the exchange, and the conditional order retains its original attributes.

Supports passing additional parameters (option) through the side parameter to modify other attributes of the conditional order. Additional parameters need to be merged with the side parameter in the format "side;{JSON object}" (recommended) or "side;key=value" (URL encoded format). For example, to modify the trigger price type: "buy;{\"newTpTriggerPxType\":\"index\"}".

For market order modification of conditional orders, you need to check whether the exchange API supports it. Setting TpOrderPrice or SlOrderPrice to -1 in the condition parameter indicates a market order.

When modifying a conditional order, other attributes of the conditional order (such as condition type, position mode, account mode, leverage, etc.) usually retain the original conditional order settings. If you need to modify these attributes, you can pass them through additional parameters (option), provided that the exchange API supports it.

You can modify the trigger price type through additional parameters, for example, changing the trigger price type from last price (last) to index price (index) or mark price (mark). The specific parameter names and support depend on the exchange API documentation.

Support for the modify conditional order function depends on the specific exchange. Some exchanges may not support the modify conditional order function or may only support modification of certain parameters. Please refer to the corresponding exchange's API documentation before use.

exchange.CancelConditionOrder

The exchange.CancelConditionOrder() function is used to cancel a conditional order. The conditional order ID format is similar to regular order IDs, consisting of the exchange instrument code and the exchange's original conditional order ID, separated by a comma.

When calling the exchange.CancelConditionOrder() function to cancel a conditional order, the conditionOrderId parameter passed should match the Id property of the conditional order structure.

    
    
    
exchange.CancelConditionOrder(conditionOrderId)

    
    
    
exchange.CancelConditionOrder(conditionOrderId, ...args)

Examples

• Cancel a conditional order.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main(){
      // Create a stop-loss conditional order
      var condition = {
          ConditionType: ORDER_CONDITION_TYPE_SL,
          SlTriggerPrice: 58000,
          SlOrderPrice: -1  // Market order
      }
      var id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Sleep(1000)
      exchange.CancelConditionOrder(id)
  }
  

  
      python
      
      
  def main():
      # Create a stop-loss conditional order
      condition = {
          "ConditionType": ORDER_CONDITION_TYPE_SL,
          "SlTriggerPrice": 58000,
          "SlOrderPrice": -1  # Market order
      }
      id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Sleep(1000)
      exchange.CancelConditionOrder(id)
  

  
      c++
      
      
  void main() {
      // Create a stop-loss conditional order
      OrderCondition condition = {.ConditionType = ORDER_CONDITION_TYPE_SL, .SlTriggerPrice = 58000, .SlOrderPrice = -1};
      auto id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition);
      Sleep(1000);
      exchange.CancelConditionOrder(id);
  }
  

• Batch cancel condition orders and output condition order information.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Create several condition orders
      var condition1 = {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 65000,
          TpOrderPrice: 65000
      }
      exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition1)
  
      var condition2 = {
          ConditionType: ORDER_CONDITION_TYPE_SL,
          SlTriggerPrice: 58000,
          SlOrderPrice: 58000
      }
      exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition2)
      Sleep(1000)
  
      var orders = exchange.GetConditionOrders()
      for (var i = 0 ; i < orders.length ; i++) {
          exchange.CancelConditionOrder(orders[i].Id, "Canceled condition order:", orders[i])
          Sleep(500)
      }
  }
  

  
      python
      
      
  def main():
      # Create several condition orders
      condition1 = {
          "ConditionType": ORDER_CONDITION_TYPE_TP,
          "TpTriggerPrice": 65000,
          "TpOrderPrice": 65000
      }
      exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition1)
  
      condition2 = {
          "ConditionType": ORDER_CONDITION_TYPE_SL,
          "SlTriggerPrice": 58000,
          "SlOrderPrice": 58000
      }
      exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition2)
      Sleep(1000)
  
      orders = exchange.GetConditionOrders()
      for i in range(len(orders)):
          exchange.CancelConditionOrder(orders[i]["Id"], "Canceled condition order:", orders[i])
          Sleep(500)
  

  
      c++
      
      
  void main() {
      // Create several condition orders
      OrderCondition condition1 = {.ConditionType = ORDER_CONDITION_TYPE_TP, .TpTriggerPrice = 65000, .TpOrderPrice = 65000};
      exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition1);
  
      OrderCondition condition2 = {.ConditionType = ORDER_CONDITION_TYPE_SL, .SlTriggerPrice = 58000, .SlOrderPrice = 58000};
      exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition2);
      Sleep(1000);
  
      auto orders = exchange.GetConditionOrders();
      for (int i = 0 ; i < orders.size() ; i++) {
          exchange.CancelConditionOrder(orders[i].Id, "Canceled condition order:", orders[i]);
          Sleep(500);
      }
  }
  

Returns

Arguments

See Also

Remarks

The return value of the exchange.CancelConditionOrder() function only indicates whether the request was sent successfully or failed. To determine whether the exchange has actually canceled the conditional order, you can call the exchange.GetConditionOrders() function to confirm.

Only untriggered conditional orders can be canceled. Conditional orders that have been triggered and converted to regular orders cannot be canceled through this function.

exchange.GetConditionOrder

The exchange.GetConditionOrder() function is used to get conditional order information.

    
    
    
exchange.GetConditionOrder(conditionOrderId)

Examples

    javascript
    
    
function main(){
    // Create take-profit conditional order
    var condition = {
        ConditionType: ORDER_CONDITION_TYPE_TP,
        TpTriggerPrice: 65000,
        TpOrderPrice: 65000
    }
    var id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
    Sleep(1000)

    // The parameter id is the conditional order ID, enter the ID of the conditional order you want to query
    var order = exchange.GetConditionOrder(id)
    Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount,
        "Status:", order.Status, "Type:", order.Type, "Condition:", order.Condition)
}

    python
    
    
def main():
    # Create take-profit conditional order
    condition = {
        "ConditionType": ORDER_CONDITION_TYPE_TP,
        "TpTriggerPrice": 65000,
        "TpOrderPrice": 65000
    }
    id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
    Sleep(1000)

    order = exchange.GetConditionOrder(id)
    Log("Id:", order["Id"], "Price:", order["Price"], "Amount:", order["Amount"],
        "Status:", order["Status"], "Type:", order["Type"], "Condition:", order["Condition"])

    c++
    
    
void main() {
    // Create take-profit conditional order
    OrderCondition condition = {.ConditionType = ORDER_CONDITION_TYPE_TP, .TpTriggerPrice = 65000, .TpOrderPrice = 65000};
    auto id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition);
    Sleep(1000);

    auto order = exchange.GetConditionOrder(id);
    Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount,
        "Status:", order.Status, "Type:", order.Type);
}

Returns

Arguments

See Also

Remarks

Some exchanges do not support the exchange.GetConditionOrder() function.

The returned conditional order structure contains information such as trigger conditions, trigger price, order status, etc.

Conditional order statuses include: not triggered, triggered, canceled, etc. The specific status values depend on the exchange.

exchange.GetConditionOrders

The exchange.GetConditionOrders() function is used to get unfulfilled conditional orders (conditional orders that have not been triggered or canceled).

    
    
    
exchange.GetConditionOrders()

    
    
    
exchange.GetConditionOrders(symbol)

Examples

• Use a spot exchange object to create multiple condition orders and then query pending condition order information.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Create multiple condition orders
      var condition1 = {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 65000,
          TpOrderPrice: 65000
      }
      exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition1)
  
      var condition2 = {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 3200,
          TpOrderPrice: 3200
      }
      exchange.CreateConditionOrder("ETH_USDT", "sell", 0.1, condition2)
      Sleep(1000)
  
      // Query all pending condition orders
      var orders = exchange.GetConditionOrders()
      Log("Pending condition orders count:", orders.length)
      for (var i = 0; i < orders.length; i++) {
          Log("Condition order", i+1, ":", orders[i])
      }
  }
  

  
      python
      
      
  def main():
      # Create multiple condition orders
      condition1 = {
          "ConditionType": ORDER_CONDITION_TYPE_TP,
          "TpTriggerPrice": 65000,
          "TpOrderPrice": 65000
      }
      exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition1)
  
      condition2 = {
          "ConditionType": ORDER_CONDITION_TYPE_TP,
          "TpTriggerPrice": 3200,
          "TpOrderPrice": 3200
      }
      exchange.CreateConditionOrder("ETH_USDT", "sell", 0.1, condition2)
      Sleep(1000)
  
      # Query all pending condition orders
      orders = exchange.GetConditionOrders()
      Log("Pending condition orders count:", len(orders))
      for i in range(len(orders)):
          Log("Condition order", i+1, ":", orders[i])
  

  
      c++
      
      
  void main() {
      // Create multiple condition orders
      OrderCondition condition1 = {.ConditionType = ORDER_CONDITION_TYPE_TP, .TpTriggerPrice = 65000, .TpOrderPrice = 65000};
      exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition1);
  
      OrderCondition condition2 = {.ConditionType = ORDER_CONDITION_TYPE_TP, .TpTriggerPrice = 3200, .TpOrderPrice = 3200};
      exchange.CreateConditionOrder("ETH_USDT", "sell", 0.1, condition2);
      Sleep(1000);
  
      // Query all pending condition orders
      auto orders = exchange.GetConditionOrders();
      Log("Pending condition orders count:", orders.size());
      for (int i = 0; i < orders.size(); i++) {
          Log("Condition order", i+1, ":", orders[i]);
      }
  }
  

• Query pending condition orders for a specific trading pair.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Query pending condition orders for BTC_USDT trading pair
      var orders = exchange.GetConditionOrders("BTC_USDT")
      Log("BTC_USDT pending condition orders:", orders)
  }
  

  
      python
      
      
  def main():
      # Query pending condition orders for BTC_USDT trading pair
      orders = exchange.GetConditionOrders("BTC_USDT")
      Log("BTC_USDT pending condition orders:", orders)
  

  
      c++
      
      
  void main() {
      // Query pending condition orders for BTC_USDT trading pair
      auto orders = exchange.GetConditionOrders("BTC_USDT");
      Log("BTC_USDT pending condition orders:", orders);
  }
  

Returns

Arguments

See Also

Remarks

Summary of usage scenarios for the symbol parameter in the GetConditionOrders function:

Summary of query dimension ranges for futures exchange objects in the GetConditionOrders function:

When the account represented by the exchange object exchange has no unfulfilled conditional orders within the query range or for the specified trading instrument, calling this function returns an empty array, i.e., [].

Support for the conditional order feature depends on the specific exchange; some exchanges may not support the conditional order feature.

exchange.GetHistoryConditionOrders

The exchange.GetHistoryConditionOrders() function is used to get historical conditional orders (including triggered, cancelled, and expired conditional orders) for the current trading pair and contract; supports specifying specific trading instruments.

    
    
    
exchange.GetHistoryConditionOrders()

    
    
    
exchange.GetHistoryConditionOrders(symbol)

    
    
    
exchange.GetHistoryConditionOrders(symbol, since)

    
    
    
exchange.GetHistoryConditionOrders(symbol, since, limit)

    
    
    
exchange.GetHistoryConditionOrders(since)

    
    
    
exchange.GetHistoryConditionOrders(since, limit)

Examples

• Query historical conditional orders, results are returned in ascending order by time.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      var historyConditionOrders = exchange.GetHistoryConditionOrders()
      Log("Historical condition orders count:", historyConditionOrders.length)
  
      // Iterate and display, orders are sorted in ascending order by Time property
      for (var i = 0; i < historyConditionOrders.length; i++) {
          Log("Order", i+1, "Created at:", historyConditionOrders[i].Time,
              "ID:", historyConditionOrders[i].Id,
              "Status:", historyConditionOrders[i].Status)
      }
  }
  

  
      python
      
      
  def main():
      historyConditionOrders = exchange.GetHistoryConditionOrders()
      Log("Historical condition orders count:", len(historyConditionOrders))
  
      # Iterate and display, orders are sorted in ascending order by Time property
      for i in range(len(historyConditionOrders)):
          Log("Order", i+1, "Created at:", historyConditionOrders[i]["Time"],
              "ID:", historyConditionOrders[i]["Id"],
              "Status:", historyConditionOrders[i]["Status"])
  

  
      c++
      
      
  void main() {
      auto historyConditionOrders = exchange.GetHistoryConditionOrders();
      Log("Historical condition orders count:", historyConditionOrders.size());
  
      // Iterate and display, orders are sorted in ascending order by Time property
      for (int i = 0; i < historyConditionOrders.size(); i++) {
          Log("Order", i+1, "Created at:", historyConditionOrders[i].Time,
              "ID:", historyConditionOrders[i].Id,
              "Status:", historyConditionOrders[i].Status);
      }
  }
  

• Query historical conditional orders for a specified trading pair with a limit on the number of results.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Query the last 10 historical conditional orders for BTC_USDT trading pair
      var historyConditionOrders = exchange.GetHistoryConditionOrders("BTC_USDT", 0, 10)
      Log("BTC_USDT historical condition orders:", historyConditionOrders)
  }
  

  
      python
      
      
  def main():
      # Query the last 10 historical conditional orders for BTC_USDT trading pair
      historyConditionOrders = exchange.GetHistoryConditionOrders("BTC_USDT", 0, 10)
      Log("BTC_USDT historical condition orders:", historyConditionOrders)
  

  
      c++
      
      
  void main() {
      // Query the last 10 historical conditional orders for BTC_USDT trading pair
      auto historyConditionOrders = exchange.GetHistoryConditionOrders("BTC_USDT", 0, 10);
      Log("BTC_USDT historical condition orders:", historyConditionOrders);
  }
  

• Query historical conditional orders based on a specified time range.

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // Query historical conditional orders starting from a specified timestamp
      var startTime = new Date("2024-01-01").getTime()
      var historyConditionOrders = exchange.GetHistoryConditionOrders(startTime, 50)
      Log("Historical condition orders since:", historyConditionOrders)
  }
  

  
      python
      
      
  def main():
      # Query historical conditional orders starting from a specified timestamp
      import time
      startTime = int(time.mktime(time.strptime("2024-01-01", "%Y-%m-%d")) * 1000)
      historyConditionOrders = exchange.GetHistoryConditionOrders(startTime, 50)
      Log("Historical condition orders since:", historyConditionOrders)
  

  
      c++
      
      
  void main() {
      // Query historical conditional orders starting from a specified timestamp
      auto startTime = 1704067200000;  // Timestamp for 2024-01-01
      auto historyConditionOrders = exchange.GetHistoryConditionOrders(startTime, 50);
      Log("Historical condition orders since:", historyConditionOrders);
  }
  

Returns

Arguments

See Also

Remarks

• When symbol, since, and limit parameters are not specified, it defaults to querying historical conditional orders for the current trading pair and contract. It queries historical conditional orders within a certain range from the current time, with the query range determined by the exchange API's single query range.

• When the symbol parameter is specified, it queries historical conditional orders for the specified trading instrument.

• When the since parameter is specified, it queries from the since timestamp towards the current time.

• When the limit parameter is specified, it returns after querying enough entries.

• This function only supports exchanges that provide historical conditional order query interfaces.

Historical conditional orders include: triggered (converted to regular orders), cancelled, expired, and other status conditional orders.

The returned historical conditional order array is sorted in ascending order by order creation time (Time attribute), i.e., the earliest orders are at the front of the array and the latest orders are at the back.

Conditional order functionality support depends on the specific exchange; some exchanges may not support conditional order functionality or historical conditional order query functionality.

exchange.SetPrecision

The exchange.SetPrecision() function is used to set the price and order amount precision for the exchange exchange object. After setting, the system will automatically ignore the excess part of the data.

    
    
    
exchange.SetPrecision(pricePrecision, amountPrecision)

Examples

    javascript
    
    
function main(){
    // 设置价格小数位精度为2位,品种下单量小数位精度为3位
    exchange.SetPrecision(2, 3)
}

    python
    
    
def main():
    exchange.SetPrecision(2, 3)

    c++
    
    
void main() {
    exchange.SetPrecision(2, 3);
}

Arguments

See Also

Remarks

The backtesting system does not support this function. The numerical precision of the backtesting system will be handled automatically.

exchange.SetRate

Set the current exchange rate conversion ratio for the exchange object.

    
    
    
exchange.SetRate(rate)

Examples

    javascript
    
    
function main(){
    Log(exchange.GetTicker())
    // 设置汇率转换
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    // 设置为1，不转换
    exchange.SetRate(1)
}

    python
    
    
def main():
    Log(exchange.GetTicker())
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    exchange.SetRate(1)

    c++
    
    
void main() {
    Log(exchange.GetTicker());
    exchange.SetRate(7);
    Log(exchange.GetTicker());
    exchange.SetRate(1);
}

Arguments

See Also

Remarks

After setting the exchange rate value using the exchange.SetRate() function (for example, setting it to 7), all price information of the current exchange object (including market data, depth data, order prices, etc.) will be multiplied by the set exchange rate for conversion.

For example, if exchange is a USD-denominated exchange, after executing exchange.SetRate(7), all price data will be multiplied by 7, converting to prices approximately denominated in CNY.

exchange.IO

The exchange.IO() function is used to call other related interfaces of the exchange object.

    
    
    
exchange.IO(k, ...args)

Examples

• Using "api" mode to call OKX futures batch order interface, passing JSON order data through the raw parameter:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      var arrOrders = [
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
      ]
  
      // Call exchange.IO to directly access the exchange's batch order interface
      var ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", JSON.stringify(arrOrders))
      Log(ret)
  }
  

  
      python
      
      
  import json
  def main():
      arrOrders = [
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
      ]
      ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", json.dumps(arrOrders))
      Log(ret)
  

  
      c++
      
      
  void main() {
      json arrOrders = R"([
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
          {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
      ])"_json;
      auto ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", arrOrders.dump());
      Log(ret);
  }
  

• When the key-value in the params parameter is a string, the parameter value needs to be wrapped with single quotes:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  var amount = 1
  var price = 10
  var basecurrency = "ltc"
  function main () {
      // Note that amount.toString() and price.toString() have a ' character on both left and right sides
      var message = "symbol=" + basecurrency + "&amount='" + amount.toString() + "'&price='" + price.toString() + "'&side=buy" + "&type=limit"
      var id = exchange.IO("api", "POST", "/v1/order/new", message)
  }

  
      python
      
      
  amount = 1
  price = 10
  basecurrency = "ltc"
  def main():
      message = "symbol=" + basecurrency + "&amount='" + str(amount) + "'&price='" + str(price) + "'&side=buy" + "&type=limit"
      id = exchange.IO("api", "POST", "/v1/order/new", message)
  

  
      c++
      
      
  void main() {
      auto amount = 1.0;
      auto price = 10.0;
      auto basecurrency = "ltc";
      string message = format("symbol=%s&amount=\"%.1f\"&price=\"%.1f\"&side=buy&type=limit", basecurrency, amount, price);
      auto id = exchange.IO("api", "POST", "/v1/order/new", message);
  }
  

• The resource parameter supports full URLs:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      var ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
      Log(ret)
  }
  

  
      python
      
      
  def main():
      ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
      Log(ret)
  

  
      c++
      
      
  void main() {
      auto ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC");
      Log(ret);
  }
  

• GET request without using the raw parameter:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main(){
      var ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
      Log(ret)
  }
  

  
      python
      
      
  def main():
      ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
      Log(ret)
  

  
      c++
      
      
  void main() {
      auto ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT");
      Log(ret);
  }
  

• Switch trading pair at runtime:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // For example, when the live trading starts, the current trading pair of the exchange object is set to BTC_USDT, print the current trading pair ticker
      Log(exchange.GetTicker())
      // Switch trading pair to LTC_BTC
      exchange.IO("currency", "LTC_BTC")
      Log(exchange.GetTicker())
  }
  

  
      python
      
      
  def main():
      Log(exchange.GetTicker())
      exchange.IO("currency", "LTC_BTC")
      Log(exchange.GetTicker())
  

  
      c++
      
      
  void main() {
      Log(exchange.GetTicker());
      exchange.IO("currency", "LTC_BTC");
      Log(exchange.GetTicker());
  }
  

• Switch exchange interface base address:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main () {
      // exchanges[0] is the first exchange object added when creating the live trading
      exchanges[0].IO("base", "https://api.huobi.pro")
  }

  
      python
      
      
  def main():
      exchanges[0].IO("base", "https://api.huobi.pro")
  

  
      c++
      
      
  void main() {
      exchanges[0].IO("base", "https://api.huobi.pro");
  }
  

• Switch market interface base address via "mbase" (using Bitfinex as an example):

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      exchange.SetBase("https://api.bitfinex.com")
      exchange.IO("mbase", "https://api-pub.bitfinex.com")
  }
  

  
      python
      
      
  def main():
      exchange.SetBase("https://api.bitfinex.com")
      exchange.IO("mbase", "https://api-pub.bitfinex.com")
  

  
      c++
      
      
  void main() {
      exchange.SetBase("https://api.bitfinex.com");
      exchange.IO("mbase", "https://api-pub.bitfinex.com");
  }
  

• Switch between demo/live trading environment (using OKX Futures as an example):

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("simulate", true)    // Switch to demo trading environment
      // ... trading logic ...
      exchange.IO("simulate", false)   // Switch back to live trading environment
  }
  

  
      python
      
      
  def main():
      exchange.IO("simulate", True)
      # ... trading logic ...
      exchange.IO("simulate", False)
  

  
      c++
      
      
  void main() {
      exchange.IO("simulate", true);
      // ... trading logic ...
      exchange.IO("simulate", false);
  }
  

• Switch contract margin mode and position mode (using Binance Futures as an example):

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("dual", true)    // Switch to hedge mode (dual position)
      exchange.IO("dual", false)   // Switch to one-way mode
  
      exchange.SetContractType("swap")
      exchange.IO("cross", true)    // Switch to cross margin
      exchange.IO("cross", false)   // Switch to isolated margin
  }
  

  
      python
      
      
  def main():
      exchange.IO("dual", True)
      exchange.IO("dual", False)
  
      exchange.SetContractType("swap")
      exchange.IO("cross", True)
      exchange.IO("cross", False)
  

  
      c++
      
      
  void main() {
      exchange.IO("dual", true);
      exchange.IO("dual", false);
  
      exchange.SetContractType("swap");
      exchange.IO("cross", true);
      exchange.IO("cross", false);
  }
  

• Switch unified account mode (using Binance Futures as an example):

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("unified", true)   // Switch to unified account mode
      exchange.IO("unified", false)  // Switch to normal mode
  }
  

  
      python
      
      
  def main():
      exchange.IO("unified", True)
      exchange.IO("unified", False)
  

  
      c++
      
      
  void main() {
      exchange.IO("unified", true);
      exchange.IO("unified", false);
  }
  

• Set self-trade prevention mode (using Binance as an example):

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // "NONE" means disable STP mode, other parameters: "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"
      exchange.IO("selfTradePreventionMode", "NONE")
  }
  

  
      python
      
      
  def main():
      exchange.IO("selfTradePreventionMode", "NONE")
  

  
      c++
      
      
  void main() {
      exchange.IO("selfTradePreventionMode", "NONE");
  }
  

• Futures_edgeX calculate order Hash and sign:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      var strJson = `{
          "assetIdSynthetic":    "0x4554482d3900000000000000000000",
          "assetIdCollateral":   "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "assetIdFee":          "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "isBuyingSynthetic":   true,
          "amountSynthetic":     10000000,
          "amountCollateral":    13020000,
          "amountFee":           6250,
          "nonce":               676432751,
          "accountID":           601416704693633632,
          "expirationTimestamp": 484831
      }`
      var signature = exchange.IO("calcOrderHashAndSign", strJson)
      Log(signature)
  }
  

  
      python
      
      
  import json
  def main():
      params = {
          "assetIdSynthetic":    "0x4554482d3900000000000000000000",
          "assetIdCollateral":   "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "assetIdFee":          "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "isBuyingSynthetic":   True,
          "amountSynthetic":     10000000,
          "amountCollateral":    13020000,
          "amountFee":           6250,
          "nonce":               676432751,
          "accountID":           601416704693633632,
          "expirationTimestamp": 484831
      }
      signature = exchange.IO("calcOrderHashAndSign", json.dumps(params))
      Log(signature)
  

  
      c++
      
      
  void main() {
      json params = R"({
          "assetIdSynthetic":    "0x4554482d3900000000000000000000",
          "assetIdCollateral":   "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "assetIdFee":          "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "isBuyingSynthetic":   true,
          "amountSynthetic":     10000000,
          "amountCollateral":    13020000,
          "amountFee":           6250,
          "nonce":               676432751,
          "accountID":           601416704693633632,
          "expirationTimestamp": 484831
      })"_json;
      auto signature = exchange.IO("calcOrderHashAndSign", params.dump());
      Log(signature);
  }
  

• Rate mode throttling - Limit GetTicker to a maximum of 10 calls per second, returns null when exceeded:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("rate", "GetTicker", 10, "1s")
  
      for (var i = 0; i < 20; i++) {
          var ticker = exchange.GetTicker("BTC_USDT")
          if (ticker) {
              Log("Ticker:", ticker.Last)
          } else {
              Log("Rate limit exceeded")
          }
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("rate", "GetTicker", 10, "1s")
  
      for i in range(20):
          ticker = exchange.GetTicker("BTC_USDT")
          if ticker:
              Log("Ticker:", ticker["Last"])
          else:
              Log("Rate limit exceeded")
  

  
      c++
      
      
  // C++ is not supported currently

• Rate mode throttling - Use the "delay" parameter to automatically wait when limit is exceeded instead of returning null:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("rate", "GetTicker", 10, "1s", "delay")
  
      for (var i = 0; i < 20; i++) {
          var ticker = exchange.GetTicker("BTC_USDT")
          Log("Call", i+1, "Ticker:", ticker.Last)
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("rate", "GetTicker", 10, "1s", "delay")
  
      for i in range(20):
          ticker = exchange.GetTicker("BTC_USDT")
          Log("Call", i+1, "Ticker:", ticker["Last"])
  

  
      c++
      
      
  // C++ is not supported currently

• Multiple functions sharing rate limit quota:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      // GetTicker and GetDepth share the limit, combined maximum of 10 calls per second
      exchange.IO("rate", "GetTicker,GetDepth", 10, "1s")
  
      for (var i = 0; i < 20; i++) {
          if (i % 2 == 0) {
              Log("Ticker:", exchange.GetTicker("BTC_USDT"))
          } else {
              Log("Depth:", exchange.GetDepth("BTC_USDT"))
          }
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("rate", "GetTicker,GetDepth", 10, "1s")
  
      for i in range(20):
          if i % 2 == 0:
              Log("Ticker:", exchange.GetTicker("BTC_USDT"))
          else:
              Log("Depth:", exchange.GetDepth("BTC_USDT"))
  

  
      c++
      
      
  // C++ is not supported currently

• Use wildcard to limit the frequency of all API calls:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("rate", "*", 100, "1m")
  
      for (var i = 0; i < 10; i++) {
          exchange.GetTicker("BTC_USDT")
          exchange.GetDepth("BTC_USDT")
          exchange.GetAccount()
          Log("Round", i+1, "completed")
          Sleep(1000)
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("rate", "*", 100, "1m")
  
      for i in range(10):
          exchange.GetTicker("BTC_USDT")
          exchange.GetDepth("BTC_USDT")
          exchange.GetAccount()
          Log("Round", i+1, "completed")
          Sleep(1000)
  

  
      c++
      
      
  // C++ is not supported currently

• quota mode - Strict time window aligned rate limiting:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("quota", "GetTicker", 3, "1s")
  
      for (var i = 0; i < 10; i++) {
          var ticker = exchange.GetTicker("BTC_USDT")
          if (ticker) {
              Log(_D(), "Ticker:", ticker.Last)
          } else {
              Log(_D(), "Quota exceeded, waiting for next window")
          }
          Sleep(100)
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("quota", "GetTicker", 3, "1s")
  
      for i in range(10):
          ticker = exchange.GetTicker("BTC_USDT")
          if ticker:
              Log(_D(), "Ticker:", ticker["Last"])
          else:
              Log(_D(), "Quota exceeded, waiting for next window")
          Sleep(100)
  

  
      c++
      
      
  // C++ is not supported currently

• quota mode - Daily quota, reset at specified time each day:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("quota", "GetTicker", 1000, "@0815")
  
      var count = 0
      while (true) {
          var ticker = exchange.GetTicker("BTC_USDT")
          if (ticker) {
              count++
              Log("Call count:", count, "Ticker:", ticker.Last)
          } else {
              Log("Daily quota exceeded, waiting for reset at 08:15")
              Sleep(60000)  // Wait 1 minute
          }
          Sleep(1000)
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("quota", "GetTicker", 1000, "@0815")
  
      count = 0
      while True:
          ticker = exchange.GetTicker("BTC_USDT")
          if ticker:
              count += 1
              Log("Call count:", count, "Ticker:", ticker["Last"])
          else:
              Log("Daily quota exceeded, waiting for reset at 08:15")
              Sleep(60000)  # Wait 1 minute
          Sleep(1000)
  

  
      c++
      
      
  // C++ is not supported currently

• Combining multiple rate limiting rules:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("rate", "GetTicker", 10, "1s")      // GetTicker 10 times per second
      exchange.IO("rate", "GetDepth", 5, "1s")        // GetDepth 5 times per second
      exchange.IO("rate", "CreateOrder", 2, "1s")     // CreateOrder 2 times per second
      exchange.IO("quota", "*", 1000, "@0000")        // All APIs reset daily at 00:00, limited to 1000 calls
  
      Log("Rate limits configured successfully")
  
      for (var i = 0; i < 5; i++) {
          exchange.GetTicker("BTC_USDT")
          exchange.GetDepth("BTC_USDT")
          Sleep(200)
      }
  }
  

  
      python
      
      
  def main():
      exchange.IO("rate", "GetTicker", 10, "1s")      # GetTicker 10 times per second
      exchange.IO("rate", "GetDepth", 5, "1s")        # GetDepth 5 times per second
      exchange.IO("rate", "CreateOrder", 2, "1s")     # CreateOrder 2 times per second
      exchange.IO("quota", "*", 1000, "@0000")        # All APIs reset daily at 00:00, limited to 1000 calls
  
      Log("Rate limits configured successfully")
  
      for i in range(5):
          exchange.GetTicker("BTC_USDT")
          exchange.GetDepth("BTC_USDT")
          Sleep(200)
  

  
      c++
      
      
  // C++ is not supported currently