exchange.GetOrders

The exchange.GetOrders() function is used to obtain the current unfilled orders.

    
    
    
exchange.GetOrders()

    
    
    
exchange.GetOrders(symbol)

Examples

• Using a spot exchange object, place buy orders for multiple different trading pairs at half of the current price as the order price, then query the information of unfilled orders.

  • javascript
  • python
  • rust
  • 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) +  "`")
  
      // Print the information once and then return, to prevent orders from being filled during subsequent backtesting, which would affect data observation
      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
  

  
      rust
      
      
  /*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"}]
  */
  
  fn main() {
      let arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"];
  
      for symbol in arrSymbol {
          let t = exchange.GetTicker(symbol).unwrap();
          let _ = exchange.CreateOrder(symbol, "buy", t.Last / 2.0, 0.01);
      }
  
      let spotOrders = exchange.GetOrders(None).unwrap();
  
      // Rust does not support JSON.stringify, use format! to build the table's JSON text
      let mut tbls = Vec::new();
      for orders in [&spotOrders] {
          let mut rows = Vec::new();
          for order in orders {
              rows.push(format!(r#"["{}", "{}", {}, {}, {}, {}, {}, {}, {}, "{}"]"#,
                  order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType));
          }
          let tbl = format!(r#"{{"type": "table", "title": "test GetOrders", "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": [{}]}}"#,
              rows.join(","));
          tbls.push(tbl);
      }
  
      LogStatus!(format!("`[{}]`", tbls.join(",")));
  
      // Print the information once and then return, to prevent orders from being filled during subsequent backtesting, which would affect data observation
      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 the futures exchange object to place orders on multiple symbols with different trading pairs and contract codes. The order prices are set far away from the counterparty price at the top of the order book, keeping the orders in an unfilled state, and then query the orders in various ways.

  • javascript
  • python
  • rust
  • 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) +  "`")
  
      // Print the output once and then return immediately, to prevent orders from being filled later in the backtest and affecting the data observation
      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
  

  
      rust
      
      
  /*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"}]
  */
  
  fn main() {
      let arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"];
  
      for symbol in arrSymbol {
          let t = exchange.GetTicker(symbol).unwrap();
          let _ = exchange.CreateOrder(symbol, "buy", t.Last / 2.0, 1);
          let _ = exchange.CreateOrder(symbol, "sell", t.Last * 2.0, 1);
      }
  
      let defaultOrders = exchange.GetOrders(None).unwrap();
      let swapOrders = exchange.GetOrders("USDT.swap").unwrap();
      let futuresOrders = exchange.GetOrders("USDT.futures").unwrap();
      let btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap").unwrap();
  
      // Rust does not support JSON.stringify, so format! is used here to assemble the JSON text of the table
      let mut tbls = Vec::new();
      let arr = [&defaultOrders, &swapOrders, &futuresOrders, &btcUsdtSwapOrders];
      let tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"];
      for index in 0..arr.len() {
          let orders = arr[index];
          let mut rows = Vec::new();
          for order in orders {
              rows.push(format!(r#"["{}", "{}", {}, {}, {}, {}, {}, {}, {}, "{}"]"#,
                  order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType));
          }
          let tbl = format!(r#"{{"type": "table", "title": "{}", "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": [{}]}}"#,
              tblDesc[index], rows.join(","));
          tbls.push(tbl);
      }
  
      LogStatus!(format!("`[{}]`", tbls.join(",")));
  
      // Print the output once and then return immediately, to prevent orders from being filled later in the backtest and affecting the data observation
      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));    // The Id attribute in the Order struct is of type TId, so the FMZ platform's built-in C++ function to_string is used here for encoding
              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, you can pass in the Symbol parameter to request order data for a specific trading pair or contract code.

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var orders = exchange.GetOrders("BTC_USDT")           // Spot symbol example
      // var orders = exchange.GetOrders("BTC_USDT.swap")   // Futures symbol example
      Log("orders:", orders)
  }
  

  
      python
      
      
  def main():
      orders = exchange.GetOrders("BTC_USDT")          # Spot symbol example
      # orders = exchange.GetOrders("BTC_USDT.swap")   # Futures symbol example
      Log("orders:", orders)
  

  
      rust
      
      
  fn main() {
      let orders = exchange.GetOrders("BTC_USDT");           // Spot symbol example
      // let orders = exchange.GetOrders("BTC_USDT.swap");   // Futures symbol example
      Log!("orders:", orders);
  }
  

  
      c++
      
      
  void main() {
      auto orders = exchange.GetOrders("BTC_USDT");           // Spot symbol example
      // auto orders = exchange.GetOrders("BTC_USDT.swap");   // Futures symbol example
      Log("orders:", orders);
  }
  

Returns

Arguments

See Also

Remarks

In the GetOrders function, the use cases of the symbol parameter are summarized as follows:

In the GetOrders function, the query dimension ranges for a futures exchange object are summarized as follows:

When the account represented by the exchange object exchange has no open orders (i.e., active orders in an unfilled state) within the query range or on the specified trading instrument, calling this function will return an empty array, that is: [].

The following exchanges require a symbol parameter to be passed in for the interface that queries current unfilled orders. When calling the GetOrders function on these exchanges, if the symbol parameter is not passed in, only the unfilled orders of the current instrument are requested, rather than the unfilled orders of all instruments (because the exchange interface does not support it).

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

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