exchange.Buy

exchange.Buy()函数用于下买单。Buy()函数是交易所对象exchange的成员函数。Buy()函数操作交易所对象exchange所绑定的交易所账户。exchange对象的成员函数（方法）的用途仅与exchange相关，本文档后续不再赘述。

    
    
    
exchange.Buy(price, amount)

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

示例

• exchange.Buy()返回的订单编号，可用于查询订单信息和取消订单。

  • javascript
  • python
  • rust
  • cpp

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

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

  
      rust
      
      
  fn main() {
      let id = exchange.Buy(100, 1).unwrap();
      Log!("id:", id);
  }
  

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

• 加密货币期货合约下单时必须注意交易方向是否设置正确，如果交易方向与交易函数不匹配将会报错：

  ```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
  • rust
  • cpp

  
      javascript
      
      
  // 以下为错误调用
  function main() {
      exchange.SetContractType("quarter")
  
      // 设置做空方向
      exchange.SetDirection("sell")
      // 下买单，会报错，做空只能卖出
      var id = exchange.Buy(50, 1)
  
      // 设置做多方向
      exchange.SetDirection("buy")
      // 下卖单，会报错，做多只能买入
      var id2 = exchange.Sell(60, 1)
  
      // 设置平多方向
      exchange.SetDirection("closebuy")
      // 下买单，会报错，平多只能卖出
      var id3 = exchange.Buy(-1, 1)
  
      // 设置平空方向
      exchange.SetDirection("closesell")
      // 下卖单,会报错,平空只能买入
      var id4 = exchange.Sell(-1, 1)
  }
  

  
      python
      
      
  # 以下为错误调用
  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)
  

  
      rust
      
      
  // 以下为错误调用
  fn main() {
      let _ = exchange.SetContractType("quarter");
  
      // 设置做空方向
      let _ = exchange.SetDirection("sell");
      // 下买单，会报错，做空只能卖出
      let id = exchange.Buy(50, 1);
  
      // 设置做多方向
      let _ = exchange.SetDirection("buy");
      // 下卖单，会报错，做多只能买入
      let id2 = exchange.Sell(60, 1);
  
      // 设置平多方向
      let _ = exchange.SetDirection("closebuy");
      // 下买单，会报错，平多只能卖出
      let id3 = exchange.Buy(-1, 1);
  
      // 设置平空方向
      let _ = exchange.SetDirection("closesell");
      // 下卖单,会报错,平空只能买入
      let id4 = exchange.Sell(-1, 1);
  }
  

  
      c++
      
      
  // 以下为错误调用
  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);
  }
  

• 现货市价单。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  // 例如交易对：ETH_BTC ，市价单买入
  function main() {
      // 下市价单买入，买入0.1个BTC（计价币）金额的ETH币
      exchange.Buy(-1, 0.1)
  }
  

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

  
      rust
      
      
  // 例如交易对：ETH_BTC ，市价单买入
  fn main() {
      // 下市价单买入，买入0.1个BTC（计价币）金额的ETH币
      let _ = exchange.Buy(-1, 0.1);
  }
  

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

返回值

参数

参考

备注

期货合约下单时必须注意交易方向是否设置正确，如果交易方向与交易函数不匹配将会报错。加密货币期货合约交易所的下单量如无特殊说明，则以合约张数为单位。

参数price设置为-1时用于下市价单，此功能需要交易所的下单接口支持市价单。以市价单方式对加密货币现货下买单时，下单量参数amount为以计价币计价的金额数量。以市价单方式对加密货币期货合约下单时，下单量参数amount的单位为合约张数。实盘时，有少数加密货币交易所不支持市价单接口。个别现货交易所市价单买单的下单量为交易币数量，具体请查看「用户指南」中的交易所特殊说明。

如使用较旧版本的托管者，exchange.Buy()函数返回的订单Id可能与当前文档中描述的返回值订单Id有所差别。

需要注意，以下三家交易所的下单接口较为特殊。对于现货市价单的买单，其下单量为币数，而非金额。

• AscendEx

• BitMEX

• Bitfinex

exchange.Sell

exchange.Sell()函数用于下达卖单。

    
    
    
exchange.Sell(price, amount)

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

示例

• exchange.Sell()返回的订单编号，可用于查询订单信息和取消订单。

  • javascript
  • python
  • rust
  • cpp

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

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

  
      rust
      
      
  fn main() {
      let id = exchange.Sell(100, 1).unwrap();
      Log!("id:", id);
  }
  

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

• 加密货币期货合约下单时必须注意交易方向是否设置正确，如果交易方向与交易函数不匹配将会报错：

  
              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
  • rust
  • cpp

  
      javascript
      
      
  // 以下为错误调用
  function main() {
      exchange.SetContractType("quarter")
  
      // 设置做空方向
      exchange.SetDirection("sell")
      // 下买单，会报错，做空只能卖出
      var id = exchange.Buy(50, 1)
  
      // 设置做多方向
      exchange.SetDirection("buy")
      // 下卖单，会报错，做多只能买入
      var id2 = exchange.Sell(60, 1)
  
      // 设置平多方向
      exchange.SetDirection("closebuy")
      // 下买单，会报错，平多只能卖出
      var id3 = exchange.Buy(-1, 1)
  
      // 设置平空方向
      exchange.SetDirection("closesell")
      // 下卖单,会报错,平空只能买入
      var id4 = exchange.Sell(-1, 1)
  }
  

  
      python
      
      
  # 以下为错误调用
  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)
  

  
      rust
      
      
  // 以下为错误调用
  fn main() {
      let _ = exchange.SetContractType("quarter");
  
      // 设置做空方向
      let _ = exchange.SetDirection("sell");
      // 下买单，会报错，做空只能卖出
      let id = exchange.Buy(50, 1);
  
      // 设置做多方向
      let _ = exchange.SetDirection("buy");
      // 下卖单，会报错，做多只能买入
      let id2 = exchange.Sell(60, 1);
  
      // 设置平多方向
      let _ = exchange.SetDirection("closebuy");
      // 下买单，会报错，平多只能卖出
      let id3 = exchange.Buy(-1, 1);
  
      // 设置平空方向
      let _ = exchange.SetDirection("closesell");
      // 下卖单,会报错,平空只能买入
      let id4 = exchange.Sell(-1, 1);
  }
  

  
      c++
      
      
  // 以下为错误调用
  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);
  }
  

• 现货市价单。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  // 例如交易对：ETH_BTC,市价单卖出
  function main() {
      // 注意：下市价单卖出，卖出0.2个ETH
      exchange.Sell(-1, 0.2)
  }
  

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

  
      rust
      
      
  // 例如交易对：ETH_BTC,市价单卖出
  fn main() {
      // 注意：下市价单卖出，卖出0.2个ETH
      let _ = exchange.Sell(-1, 0.2);
  }
  

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

返回值

参数

参考

备注

期货合约下单时必须注意交易方向是否设置正确，如果交易方向与交易函数不匹配将会报错。加密货币期货合约交易所的下单量如无特殊说明则以合约张数为单位。

参数price设置为-1时用于下达市价单，需要交易所的下单接口支持市价单。以市价单方式交易加密货币现货时，下卖单时，下单量参数amount以交易币为单位。以市价单方式交易加密货币期货合约时，下单量参数amount以合约张数为单位。实盘时，有少数加密货币交易所不支持市价单接口。

如使用较旧版本的托管者，exchange.Sell()函数返回的订单Id可能与当前文档中描述的返回值订单Id有所差别。

exchange.CreateOrder

exchange.CreateOrder()函数用于下单。

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

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

示例

• 现货交易所对象与期货交易所对象均通过调用exchange.CreateOrder()函数进行下单。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01)           // 现货交易所对象下单，交易BTC_USDT币币交易对
      // var id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01)   // 期货交易所对象下单，交易BTC的U本位永续合约
      Log("Order Id:", id)
  }
  

  
      python
      
      
  def main():
      id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01)          # 现货交易所对象下单，交易BTC_USDT币币交易对
      # id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01)   # 期货交易所对象下单，交易BTC的U本位永续合约
      Log("Order Id:", id)
  

  
      rust
      
      
  fn main() {
      let id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01);           // 现货交易所对象下单，交易BTC_USDT币币交易对
      // let id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01);   // 期货交易所对象下单，交易BTC的U本位永续合约
      Log!("Order Id:", id);
  }
  

  
      c++
      
      
  void main() {
      auto id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01);           // 现货交易所对象下单，交易BTC_USDT币币交易对
      // auto id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01);   // 期货交易所对象下单，交易BTC的U本位永续合约
      Log("Order Id:", id);
  }
  

• 通过附加参数（option）下单，用于传递交易所的特定参数。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 使用JSON格式传递option参数
      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():
      # 使用JSON格式传递option参数
      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))
  

  
      rust
      
      
  fn main() {
      // 使用JSON格式传递option参数（Rust不支持JSON.stringify，直接使用原始字符串构造JSON文本）
      let option = r#"{"type": "TRAILING_STOP_MARKET", "activationPrice": "2300", "callbackRate": "0.1"}"#;
      let sideWithOption = format!("buy;{}", option);
      let id = exchange.CreateOrder("SOL_USDT.swap", &sideWithOption, -1, 1).unwrap();
      Log!("Order Id:", id);
  
      Sleep(2000);
      Log!(exchange.GetOrder(&id));
  }
  

  
      c++
      
      
  void main() {
      // 使用JSON格式传递option参数
      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));
  }
  

返回值

参数

参考

备注

支持通过side参数传递附加参数（option），用于指定交易所特定的参数。附加参数需与side参数合并传入，格式为"side;{JSON对象}"（推荐）或"side;key=value&key=value"（URL编码格式）。例如："buy;{\"type\":\"TRAILING_STOP_MARKET\"}"。

不同交易所支持的option参数各不相同，具体支持的参数以交易所API文档为准。常见参数包括：订单类型（type）、生效规则（timeInForce）、触发价格（activationPrice）、回调比率（callbackRate）等。

使用option参数时，仍需提供price和amount参数。若某些参数已通过option传递，则这些基础参数可能会被option中的对应参数覆盖，具体行为取决于交易所API的实现。

exchange.CancelOrder

exchange.CancelOrder()函数用于取消订单。FMZ平台的订单Order结构中，属性Id由交易所品种代码和交易所原始订单Id组成，两者之间以英文逗号分隔。例如，OKX交易所现货交易对ETH_USDT的订单，其属性Id的格式为：ETH-USDT,1547130415509278720。

调用exchange.CancelOrder()函数撤销订单时，传入的参数orderId与订单Order结构的Id属性一致。

    
    
    
exchange.CancelOrder(orderId)

    
    
    
exchange.CancelOrder(orderId, ...args)

示例

• 撤销订单。

  • javascript
  • python
  • rust
  • cpp

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

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

  
      rust
      
      
  fn main() {
      let id = exchange.Sell(99999, 1).unwrap();
      let _ = exchange.CancelOrder(&id);
  }
  

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

• FMZ的API函数中，能够产生日志输出的函数（例如Log()、exchange.Buy()、exchange.CancelOrder()等）都可以在必要参数之后附带一些输出参数。

  例如：exchange.CancelOrder(orders[i].Id, orders[i])，即在取消Id为orders[i].Id的订单时，附带输出该订单的信息，也就是orders[i]这个Order结构。

  • javascript
  • python
  • rust
  • 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)
  

  
      rust
      
      
  fn main() {
      if exchange.GetName().contains("Futures_") {
          Log!("Set contract to: perpetual swap, set direction to: open long.");
          let _ = exchange.SetContractType("swap");
          let _ = exchange.SetDirection("buy");
      }
  
      let ticker = exchange.GetTicker(None).unwrap();
      let _ = exchange.Buy(ticker.Last * 0.5, 0.1);
  
      let orders = exchange.GetOrders(None).unwrap();
      for i in 0..orders.len() {
          // Rust不支持在CancelOrder的必要参数后附带输出参数，撤单后单独调用Log!宏输出附带信息
          let _ = exchange.CancelOrder(&orders[i].Id);
          Log!("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);
      }
  }
  

返回值

参数

参考

备注

如果使用较旧版本的托管者，exchange.CancelOrder()函数的参数orderId可能与当前文档中描述的orderId有所差别。

exchange.GetOrder

exchange.GetOrder()函数用于获取订单信息。

    
    
    
exchange.GetOrder(orderId)

示例

    javascript
    
    
function main(){
    var id = exchange.Sell(1000, 1)
    // 参数id为订单号码，需填入你想要查询的订单的号码
    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"])

    rust
    
    
fn main() {
    let id = exchange.Sell(1000, 1).unwrap();
    // 参数id为订单号码，需填入你想要查询的订单的号码
    let order = exchange.GetOrder(&id).unwrap();
    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);
}

返回值

参数

参考

备注

部分交易所不支持exchange.GetOrder()函数。返回值Order结构中的AvgPrice属性为成交均价，部分交易所不支持该字段，若不支持则将其设置为0。

如果使用较旧版本的托管者，exchange.GetOrder()函数的参数orderId可能与当前文档中描述的orderId存在差异。

不支持exchange.GetOrder()函数的交易所：

exchange.GetOrders

exchange.GetOrders()函数用于获取当前未完成的订单。

    
    
    
exchange.GetOrders()

    
    
    
exchange.GetOrders(symbol)

示例

• 使用现货交易所对象，针对多个不同的交易对，以当前价格的一半作为下单价格挂出买单，随后查询未成交订单的信息。

  • 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) +  "`")
  
      // 打印输出一次信息后返回，防止后续回测时订单成交，影响数据观察
      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不支持JSON.stringify，使用format!拼接表格的JSON文本
      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(",")));
  
      // 打印输出一次信息后返回，防止后续回测时订单成交，影响数据观察
      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;
  }
  

• 使用期货交易所对象，对多个不同交易对、不同合约代码的品种进行下单。下单价格远离盘口对手价，使订单保持未成交状态，并按多种方式查询订单。

  • 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) +  "`")
  
      // 打印输出一次信息后立即返回，防止后续回测过程中订单成交而影响数据观察
      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 不支持 JSON.stringify，此处使用 format! 拼接表格的 JSON 文本
      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(",")));
  
      // 打印输出一次信息后立即返回，防止后续回测过程中订单成交而影响数据观察
      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;
  }
  

• 调用exchange.GetOrders()函数时，可传入Symbol参数以指定请求特定交易对或合约代码的订单数据。

  • javascript
  • python
  • rust
  • 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)
  

  
      rust
      
      
  fn main() {
      let orders = exchange.GetOrders("BTC_USDT");           // 现货品种示例
      // let 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);
  }
  

返回值

参数

参考

备注

在GetOrders函数中，symbol参数的使用场景归纳如下：

在GetOrders函数中，期货交易所对象的查询维度范围归纳如下：

当交易所对象exchange所代表的账户在查询范围内或指定的交易品种上没有挂单（即处于未成交状态的活动订单）时，调用该函数将返回空数组，即：[]。

以下交易所查询当前未完成订单的接口必须传入品种参数。使用这些交易所调用GetOrders函数时，若未传入symbol参数，则仅请求当前品种的未完成订单，而非所有品种的未完成订单（因为交易所接口不支持）。

Zaif、MEXC、LBank、Korbit、Coinw、BitMart、Bithumb、BitFlyer、BigONE。

不支持exchange.GetOrders()函数的交易所：

exchange.GetHistoryOrders

exchange.GetHistoryOrders()函数用于获取当前交易对、合约的历史订单，并支持指定具体的交易品种。

    
    
    
exchange.GetHistoryOrders()

    
    
    
exchange.GetHistoryOrders(symbol)

    
    
    
exchange.GetHistoryOrders(symbol, since)

    
    
    
exchange.GetHistoryOrders(symbol, since, limit)

    
    
    
exchange.GetHistoryOrders(since)

    
    
    
exchange.GetHistoryOrders(since, limit)

示例

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

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

    rust
    
    
fn main() {
    let historyOrders = exchange.GetHistoryOrders(None, None, None);
    Log!(historyOrders);
}

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

返回值

参数

参考

备注

• 未指定symbol、since、limit参数时，默认查询当前交易对、合约的历史订单，即查询距当前时间最近的一定范围内的历史订单，具体查询范围取决于交易所接口的单次查询范围。

• 指定symbol参数时，查询所设置交易品种的历史订单。

• 指定since参数时，以since时间戳为起始时间，向当前时间方向查询。

• 指定limit参数时，查询到足够条数后返回。

• 该函数仅支持提供历史订单查询接口的交易所。

不支持exchange.GetHistoryOrders()函数的交易所：

exchange.CreateConditionOrder

exchange.CreateConditionOrder()函数用于创建条件单。条件单是一种在满足特定触发条件时自动执行的订单类型。

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

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

示例

• 创建止盈单（TP）：当价格上涨至目标价位时自动卖出。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 创建止盈单：当BTC_USDT价格上涨至65000时，以65000的价格卖出0.01个BTC
      var condition = {
          ConditionType: ORDER_CONDITION_TYPE_TP,  // 止盈单
          TpTriggerPrice: 65000,   // 触发价格
          TpOrderPrice: 65000      // 执行价格，也可设置为-1表示市价单
      }
      var id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Log("TP order Id:", id)
  }
  

  
      python
      
      
  def main():
      # 创建止盈单：当BTC_USDT价格上涨至65000时，以65000的价格卖出0.01个BTC
      condition = {
          "ConditionType": ORDER_CONDITION_TYPE_TP,  # 止盈单
          "TpTriggerPrice": 65000,   # 触发价格
          "TpOrderPrice": 65000      # 执行价格，也可设置为-1表示市价单
      }
      id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Log("TP order Id:", id)
  

  
      rust
      
      
  fn main() {
      // 创建止盈单：当BTC_USDT价格上涨至65000时，以65000的价格卖出0.01个BTC
      let condition = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_TP,  // 止盈单
          TpTriggerPrice: 65000.0,   // 触发价格
          TpOrderPrice: 65000.0,     // 执行价格，也可设置为-1表示市价单
          ..Default::default()
      };
      let id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, &condition);
      Log!("TP order Id:", id);
  }
  

  
      c++
      
      
  void main() {
      // 创建止盈单：当BTC_USDT价格上涨至65000时，以65000的价格卖出0.01个BTC
      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);
  }
  

• 创建止损单（SL）：当价格下跌至止损触发价位时，自动以设定方式卖出。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 创建止损单：当BTC_USDT价格下跌至58000时，以市价卖出0.01个BTC
      var condition = {
          ConditionType: ORDER_CONDITION_TYPE_SL,  // 止损单
          SlTriggerPrice: 58000,   // 触发价格
          SlOrderPrice: -1         // -1表示市价单
      }
      var id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Log("SL order Id:", id)
  }
  

  
      python
      
      
  def main():
      # 创建止损单：当BTC_USDT价格下跌至58000时，以市价卖出0.01个BTC
      condition = {
          "ConditionType": ORDER_CONDITION_TYPE_SL,  # 止损单
          "SlTriggerPrice": 58000,   # 触发价格
          "SlOrderPrice": -1         # -1表示市价单
      }
      id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Log("SL order Id:", id)
  

  
      rust
      
      
  fn main() {
      // 创建止损单：当BTC_USDT价格下跌至58000时，以市价卖出0.01个BTC
      let condition = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_SL,  // 止损单
          SlTriggerPrice: 58000.0,   // 触发价格
          SlOrderPrice: -1.0,        // -1表示市价单
          ..Default::default()
      };
      let id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, &condition);
      Log!("SL order Id:", id);
  }
  

  
      c++
      
      
  void main() {
      // 创建止损单：当BTC_USDT价格下跌至58000时，以市价卖出0.01个BTC
      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);
  }
  

• 创建 OCO 订单：同时设置止盈和止损，任意一个触发后，另一个将自动取消。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 创建 OCO 订单：止盈价 65000，止损价 58000
      var condition = {
          ConditionType: ORDER_CONDITION_TYPE_OCO,  // OCO 订单
          TpTriggerPrice: 65000,   // 止盈触发价格
          TpOrderPrice: 65000,     // 止盈执行价格
          SlTriggerPrice: 58000,   // 止损触发价格
          SlOrderPrice: 58000      // 止损执行价格
      }
      var id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Log("OCO order Id:", id)
  }
  

  
      python
      
      
  def main():
      # 创建 OCO 订单：止盈价 65000，止损价 58000
      condition = {
          "ConditionType": ORDER_CONDITION_TYPE_OCO,  # OCO 订单
          "TpTriggerPrice": 65000,   # 止盈触发价格
          "TpOrderPrice": 65000,     # 止盈执行价格
          "SlTriggerPrice": 58000,   # 止损触发价格
          "SlOrderPrice": 58000      # 止损执行价格
      }
      id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Log("OCO order Id:", id)
  

  
      rust
      
      
  fn main() {
      // 创建 OCO 订单：止盈价 65000，止损价 58000
      let condition = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_OCO,  // OCO 订单
          TpTriggerPrice: 65000.0,   // 止盈触发价格
          TpOrderPrice: 65000.0,     // 止盈执行价格
          SlTriggerPrice: 58000.0,   // 止损触发价格
          SlOrderPrice: 58000.0      // 止损执行价格
      };
      let id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, &condition);
      Log!("OCO order Id:", id);
  }
  

  
      c++
      
      
  void main() {
      // 创建 OCO 订单：止盈价 65000，止损价 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);
  }
  

• 使用附加参数（option）创建条件单，用于传递交易所特定的参数。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 以 JSON 格式传递 option 参数
      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():
      # 以 JSON 格式传递 option 参数
      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))
  

  
      rust
      
      
  fn main() {
      // 以 JSON 格式传递 option 参数（Rust 无 JSON 序列化功能，此处直接使用原始字符串构造）
      let option = r#"{"type": "TRAILING_STOP_MARKET", "activatePrice": "300", "callbackRate": "0.1"}"#;
      let sideWithOption = format!("buy;{}", option);
      let condition = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 77.0,
          TpOrderPrice: 71.0,
          ..Default::default()
      };
      let id = exchange.CreateConditionOrder("SOL_USDT.swap", &sideWithOption, 1, &condition).unwrap();
      Log!("Condition Order Id:", id);
  
      Sleep(2000);
      Log!(exchange.GetConditionOrder(&id));
  }
  

  
      c++
      
      
  void main() {
      // 以 JSON 格式传递 option 参数
      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));
  }
  

返回值

参数

参考

备注

条件单功能的支持情况取决于具体交易所，部分交易所可能不支持条件单功能。

条件单在触发前不会占用账户资金，仅在触发后才会实际下单并占用资金。

不同交易所对条件单的支持程度及具体参数可能有所差异，使用前请查阅对应交易所的 API 文档。

支持通过side参数传递附加参数（option），用于传递交易所特定的参数。附加参数需与side参数合并传入，格式为"side;{JSON对象}"（推荐）或"side;key=value&key=value"（URL 编码格式）。例如："buy;{\"type\":\"TRAILING_STOP_MARKET\"}"。

不同交易所支持的 option 参数各不相同，具体支持的参数取决于交易所 API 文档。常见参数包括：订单类型（type）、生效规则（timeInForce）、触发价格（activatePrice）、回调比率（callbackRate）等。

使用 option 参数时，仍需提供amount和condition参数。如果交易所 API 中的某些参数已通过 option 传递，这些基础参数可能会被 option 中的对应参数覆盖，具体行为取决于交易所 API 的实现。

exchange.ModifyOrder

exchange.ModifyOrder()函数用于修改现有的普通订单，可修改订单的价格和数量。该函数支持通过附加参数修改订单的其它属性（具体取决于交易所 API 的支持情况）。

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

示例

• 修改普通订单的价格和数量。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 创建一个限价买单
      var id = exchange.CreateOrder("SOL_USDT.swap", "buy", 88, 1)
      Log("Original Order ID:", id)
      Sleep(2000)
  
      // 查询原始订单信息
      var order = exchange.GetOrder(id)
      Log("Original Order Info:", order)
      Sleep(1000)
  
      // 修改订单的价格和数量
      var newId = exchange.ModifyOrder(id, "buy", 77, 2)
      Log("Modified Order ID:", newId)
      Sleep(2000)
  
      // 查询修改后的订单信息
      var newOrder = exchange.GetOrder(newId)
      Log("Modified Order Info:", newOrder)
  
      // 取消订单
      exchange.CancelOrder(newId)
  }
  

  
      python
      
      
  def main():
      # 创建一个限价买单
      id = exchange.CreateOrder("SOL_USDT.swap", "buy", 88, 1)
      Log("Original Order ID:", id)
      Sleep(2000)
  
      # 查询原始订单信息
      order = exchange.GetOrder(id)
      Log("Original Order Info:", order)
      Sleep(1000)
  
      # 修改订单的价格和数量
      newId = exchange.ModifyOrder(id, "buy", 77, 2)
      Log("Modified Order ID:", newId)
      Sleep(2000)
  
      # 查询修改后的订单信息
      newOrder = exchange.GetOrder(newId)
      Log("Modified Order Info:", newOrder)
  
      # 取消订单
      exchange.CancelOrder(newId)
  

  
      rust
      
      
  fn main() {
      // 创建一个限价买单
      let id = exchange.CreateOrder("SOL_USDT.swap", "buy", 88, 1).unwrap();
      Log!("Original Order ID:", id);
      Sleep(2000);
  
      // 查询原始订单信息
      let order = exchange.GetOrder(&id).unwrap();
      Log!("Original Order Info:", order);
      Sleep(1000);
  
      // 修改订单的价格和数量
      let newId = exchange.ModifyOrder(&id, "buy", 77, 2).unwrap();
      Log!("Modified Order ID:", newId);
      Sleep(2000);
  
      // 查询修改后的订单信息
      let newOrder = exchange.GetOrder(&newId).unwrap();
      Log!("Modified Order Info:", newOrder);
  
      // 取消订单
      let _ = exchange.CancelOrder(&newId);
  }
  

  
      c++
      
      
  void main() {
      // 创建一个限价买单
      auto id = exchange.CreateOrder("SOL_USDT.swap", "buy", 88, 1);
      Log("Original Order ID:", id);
      Sleep(2000);
  
      // 查询原始订单信息
      auto order = exchange.GetOrder(id);
      Log("Original Order Info:", order);
      Sleep(1000);
  
      // 修改订单的价格和数量
      auto newId = exchange.ModifyOrder(id, "buy", 77, 2);
      Log("Modified Order ID:", newId);
      Sleep(2000);
  
      // 查询修改后的订单信息
      auto newOrder = exchange.GetOrder(newId);
      Log("Modified Order Info:", newOrder);
  
      // 取消订单
      exchange.CancelOrder(newId);
  }
  

• 使用附加参数（option）修改订单的价格匹配模式。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 创建一个限价买单
      var id = exchange.CreateOrder("SOL_USDT.swap", "buy", 77, 1)
      Log("Original Order ID:", id)
      Sleep(2000)
  
      // 修改订单，并将价格匹配模式设置为 QUEUE_20
      // 通过 side 参数传递附加参数（JSON 格式）
      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)
  
      // 查询修改后的订单信息
      var newOrder = exchange.GetOrder(newId)
      Log("Modified Order Info:", newOrder)
  
      // 撤销订单
      exchange.CancelOrder(newId)
  }
  

  
      python
      
      
  import json
  
  def main():
      # 创建一个限价买单
      id = exchange.CreateOrder("SOL_USDT.swap", "buy", 77, 1)
      Log("Original Order ID:", id)
      Sleep(2000)
  
      # 修改订单，并将价格匹配模式设置为 QUEUE_20
      # 通过 side 参数传递附加参数（JSON 格式）
      option = {"priceMatch": "QUEUE_20"}
      sideWithOption = "buy;" + json.dumps(option)
  
      newId = exchange.ModifyOrder(id, sideWithOption, -1, 2)
      Log("Modified Order ID:", newId)
      Sleep(2000)
  
      # 查询修改后的订单信息
      newOrder = exchange.GetOrder(newId)
      Log("Modified Order Info:", newOrder)
  
      # 撤销订单
      exchange.CancelOrder(newId)
  

  
      rust
      
      
  fn main() {
      // 创建一个限价买单
      let id = exchange.CreateOrder("SOL_USDT.swap", "buy", 77, 1).unwrap();
      Log!("Original Order ID:", id);
      Sleep(2000);
  
      // 修改订单，并将价格匹配模式设置为 QUEUE_20
      // 通过 side 参数传递附加参数（JSON 格式）；Rust 不支持 JSON.stringify，因此直接使用原始字符串构造 JSON 文本
      let option = r#"{"priceMatch": "QUEUE_20"}"#;
      let sideWithOption = format!("buy;{}", option);
  
      let newId = exchange.ModifyOrder(&id, &sideWithOption, -1, 2).unwrap();
      Log!("Modified Order ID:", newId);
      Sleep(2000);
  
      // 查询修改后的订单信息
      let newOrder = exchange.GetOrder(&newId).unwrap();
      Log!("Modified Order Info:", newOrder);
  
      // 撤销订单
      let _ = exchange.CancelOrder(&newId);
  }
  

  
      c++
      
      
  void main() {
      // 创建一个限价买单
      auto id = exchange.CreateOrder("SOL_USDT.swap", "buy", 77, 1);
      Log("Original Order ID:", id);
      Sleep(2000);
  
      // 修改订单，并将价格匹配模式设置为 QUEUE_20
      // 通过 side 参数传递附加参数（JSON 格式）
      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);
  
      // 查询修改后的订单信息
      auto newOrder = exchange.GetOrder(newId);
      Log("Modified Order Info:", newOrder);
  
      // 撤销订单
      exchange.CancelOrder(newId);
  }
  

返回值

参数

参考

备注

exchange.ModifyOrder()函数返回的订单 ID 因交易所 API 的实现不同而可能有不同的行为。有些交易所 API 返回的订单 ID 会更新，有些则保持不变。建议使用返回的新订单 ID 进行后续操作。

exchange.ModifyOrder()函数不会依据交易所接口规则校验参数的有效性，而是将参数直接提交给交易所 API。传入无效参数时（如价格或数量为 -1），参数可能会被交易所忽略，订单将保持原有属性不变。

支持通过side参数传递附加参数（option），用于修改订单的其它属性。附加参数需与side参数合并后传入，格式为"side;{JSON对象}"（推荐）或"side;key=value"（URL 编码格式）。例如，修改价格匹配模式："buy;{\"priceMatch\":\"QUEUE_20\"}"。

对于普通订单的市价单修改，需具体查看交易所 API 是否支持。有些交易所不支持对市价单进行修改操作。

修改订单时，订单的其它属性（如订单类型、持仓模式、账户模式、杠杆、订单生效规则等）通常会保留原订单的设置。如需修改这些属性，可通过附加参数（option）传入，前提是交易所 API 支持。

个别交易所 API 在未接收到价格参数时（price 为 -1 或 null），可能会将订单转为市价单。对于现货市价买单，需要注意其下单量单位可能是金额而非币数。

修改订单功能的支持情况取决于具体交易所，部分交易所可能不支持修改订单功能，或仅支持修改部分参数。使用前请查阅对应交易所的 API 文档。

exchange.ModifyConditionOrder

exchange.ModifyConditionOrder()函数用于修改现有的条件单，可修改条件单的下单量、触发条件和执行价格。支持通过附加参数修改条件单的其它属性（具体取决于交易所API的支持情况）。

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

示例

• 修改条件单的数量和触发条件。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 创建一个止盈条件单
      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)
  
      // 查询原始条件单信息
      var order = exchange.GetConditionOrder(id)
      Log("Original Condition Order Info:", order)
      Sleep(1000)
  
      // 修改条件单的数量和触发条件
      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)
  
      // 查询修改后的条件单信息
      var newOrder = exchange.GetConditionOrder(newId)
      Log("Modified Condition Order Info:", newOrder)
  
      // 取消条件单
      exchange.CancelConditionOrder(newId)
  }
  

  
      python
      
      
  def main():
      # 创建一个止盈条件单
      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)
  
      # 查询原始条件单信息
      order = exchange.GetConditionOrder(id)
      Log("Original Condition Order Info:", order)
      Sleep(1000)
  
      # 修改条件单的数量和触发条件
      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)
  
      # 查询修改后的条件单信息
      newOrder = exchange.GetConditionOrder(newId)
      Log("Modified Condition Order Info:", newOrder)
  
      # 取消条件单
      exchange.CancelConditionOrder(newId)
  

  
      rust
      
      
  fn main() {
      // 创建一个止盈条件单
      let condition = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 77.0,
          TpOrderPrice: 76.0,
          ..Default::default()
      };
      let id = exchange.CreateConditionOrder("SOL_USDT.swap", "buy", 1, &condition).unwrap();
      Log!("Original Condition Order ID:", id);
      Sleep(2000);
  
      // 查询原始条件单信息
      let order = exchange.GetConditionOrder(&id);
      Log!("Original Condition Order Info:", order);
      Sleep(1000);
  
      // 修改条件单的数量和触发条件
      let newCondition = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 75.0,
          TpOrderPrice: 71.0,
          ..Default::default()
      };
      let newId = exchange.ModifyConditionOrder(&id, "buy", 2, &newCondition).unwrap();
      Log!("Modified Condition Order ID:", newId);
      Sleep(2000);
  
      // 查询修改后的条件单信息
      let newOrder = exchange.GetConditionOrder(&newId);
      Log!("Modified Condition Order Info:", newOrder);
  
      // 取消条件单
      let _ = exchange.CancelConditionOrder(&newId);
  }
  

  
      c++
      
      
  void main() {
      // 创建一个止盈条件单
      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);
  
      // 查询原始条件单信息
      auto order = exchange.GetConditionOrder(id);
      Log("Original Condition Order Info:", order);
      Sleep(1000);
  
      // 修改条件单的数量和触发条件
      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);
  
      // 查询修改后的条件单信息
      auto newOrder = exchange.GetConditionOrder(newId);
      Log("Modified Condition Order Info:", newOrder);
  
      // 取消条件单
      exchange.CancelConditionOrder(newId);
  }
  

• 使用附加参数（option）修改条件单的触发价格类型。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 创建一个止盈条件单
      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)
  
      // 修改条件单，并将触发价格类型设置为指数价格（index）
      // 通过 side 参数传递附加参数（JSON 格式）
      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)
  
      // 查询修改后的条件单信息
      var newOrder = exchange.GetConditionOrder(newId)
      Log("Modified Condition Order Info:", newOrder)
  
      // 取消条件单
      exchange.CancelConditionOrder(newId)
  }
  

  
      python
      
      
  import json
  
  def main():
      # 创建一个止盈条件单
      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)
  
      # 修改条件单，并将触发价格类型设置为指数价格（index）
      # 通过 side 参数传递附加参数（JSON 格式）
      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)
  
      # 查询修改后的条件单信息
      newOrder = exchange.GetConditionOrder(newId)
      Log("Modified Condition Order Info:", newOrder)
  
      # 取消条件单
      exchange.CancelConditionOrder(newId)
  

  
      rust
      
      
  fn main() {
      // 创建一个止盈条件单
      let condition = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 77.0,
          TpOrderPrice: 76.0,
          ..Default::default()
      };
      let id = exchange.CreateConditionOrder("SOL_USDT.swap", "buy", 1, &condition).unwrap();
      Log!("Original Condition Order ID:", id);
      Sleep(2000);
  
      // 修改条件单，并将触发价格类型设置为指数价格（index）
      // 通过 side 参数传递附加参数（JSON 格式；Rust 无 JSON 序列化，故直接使用原始字符串构造）
      let sideWithOption = r#"buy;{"newTpTriggerPxType": "index"}"#;
  
      let newCondition = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 75.0,
          TpOrderPrice: 71.0,
          ..Default::default()
      };
      let newId = exchange.ModifyConditionOrder(&id, sideWithOption, 2, &newCondition).unwrap();
      Log!("Modified Condition Order ID:", newId);
      Sleep(2000);
  
      // 查询修改后的条件单信息
      let newOrder = exchange.GetConditionOrder(&newId);
      Log!("Modified Condition Order Info:", newOrder);
  
      // 取消条件单
      let _ = exchange.CancelConditionOrder(&newId);
  }
  

  
      c++
      
      
  void main() {
      // 创建一个止盈条件单
      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);
  
      // 修改条件单，并将触发价格类型设置为指数价格（index）
      // 通过 side 参数传递附加参数（JSON 格式）
      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);
  
      // 查询修改后的条件单信息
      auto newOrder = exchange.GetConditionOrder(newId);
      Log("Modified Condition Order Info:", newOrder);
  
      // 取消条件单
      exchange.CancelConditionOrder(newId);
  }
  

返回值

参数

参考

备注

exchange.ModifyConditionOrder()函数返回的条件单ID因交易所API实现的不同而可能表现出不同行为。有些交易所API返回的条件单ID会更新，有些则保持不变。建议使用返回的新条件单ID进行后续操作。

exchange.ModifyConditionOrder()函数不会依据交易所接口规则校验参数的有效性，而是将参数直接提交给交易所API。传入无效参数时（如数量为-1），该参数可能会被交易所忽略，条件单保持原有属性不变。

支持通过side参数传递附加参数（option），用于修改条件单的其它属性。附加参数需要与side参数合并传入，格式为"side;{JSON对象}"（推荐）或"side;key=value"（URL编码格式）。例如修改触发价格类型："buy;{\"newTpTriggerPxType\":\"index\"}"。

对于条件单的市价单修改，需要具体查看交易所API是否支持。将condition参数中的TpOrderPrice或SlOrderPrice设置为-1表示市价单。

修改条件单时，条件单的其它属性（如条件类型、持仓模式、账户模式、杠杆等）通常会保留原条件单的设置。如需修改这些属性，可以通过附加参数（option）传入，前提是交易所API支持。

可以通过附加参数修改触发价格类型，例如将触发价格类型从最新价（last）修改为指数价格（index）或标记价格（mark）。具体的参数名称和支持情况取决于交易所API文档。

修改条件单功能的支持情况取决于具体交易所，部分交易所可能不支持修改条件单功能，或仅支持修改部分参数。使用前请查阅对应交易所的API文档。

exchange.CancelConditionOrder

exchange.CancelConditionOrder()函数用于取消条件单。条件单Id的格式与普通订单Id类似，由交易所品种代码和交易所原始条件单Id组成，两者以英文逗号分隔。

调用exchange.CancelConditionOrder()函数撤销条件单时，传入的conditionOrderId参数与条件单结构的Id属性一致。

    
    
    
exchange.CancelConditionOrder(conditionOrderId)

    
    
    
exchange.CancelConditionOrder(conditionOrderId, ...args)

示例

• 撤销条件单。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main(){
      // 创建止损条件单
      var condition = {
          ConditionType: ORDER_CONDITION_TYPE_SL,
          SlTriggerPrice: 58000,
          SlOrderPrice: -1  // 市价单
      }
      var id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Sleep(1000)
      exchange.CancelConditionOrder(id)
  }
  

  
      python
      
      
  def main():
      # 创建止损条件单
      condition = {
          "ConditionType": ORDER_CONDITION_TYPE_SL,
          "SlTriggerPrice": 58000,
          "SlOrderPrice": -1  # 市价单
      }
      id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
      Sleep(1000)
      exchange.CancelConditionOrder(id)
  

  
      rust
      
      
  fn main() {
      // 创建止损条件单
      let condition = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_SL,
          SlTriggerPrice: 58000.0,
          SlOrderPrice: -1.0,  // 市价单
          ..Default::default()
      };
      let id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, &condition).unwrap();
      Sleep(1000);
      let _ = exchange.CancelConditionOrder(&id);
  }
  

  
      c++
      
      
  void main() {
      // 创建止损条件单
      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);
  }
  

• 批量取消条件单，并附带输出条件单信息。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 创建几个条件单
      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():
      # 创建几个条件单
      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)
  

  
      rust
      
      
  fn main() {
      // 创建几个条件单
      let condition1 = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 65000.0,
          TpOrderPrice: 65000.0,
          ..Default::default()
      };
      let _ = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, &condition1);
  
      let condition2 = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_SL,
          SlTriggerPrice: 58000.0,
          SlOrderPrice: 58000.0,
          ..Default::default()
      };
      let _ = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, &condition2);
      Sleep(1000);
  
      let orders = exchange.GetConditionOrders(None).unwrap();
      for i in 0..orders.len() {
          // Rust中CancelConditionOrder不支持扩展参数，附带信息用Log输出
          let _ = exchange.CancelConditionOrder(&orders[i].Id);
          Log!("Canceled condition order:", orders[i]);
          Sleep(500);
      }
  }
  

  
      c++
      
      
  void main() {
      // 创建几个条件单
      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);
      }
  }
  

返回值

参数

参考

备注

exchange.CancelConditionOrder()函数的返回值仅代表撤销请求发送成功或失败。如需判断交易所是否已取消该条件单，可以调用exchange.GetConditionOrders()函数进行确认。

只有未触发的条件单可以被取消；已经触发并转为普通订单的条件单无法通过此函数取消。

exchange.GetConditionOrder

exchange.GetConditionOrder()函数用于获取指定条件单的信息。

    
    
    
exchange.GetConditionOrder(conditionOrderId)

示例

    javascript
    
    
function main(){
    // 创建止盈条件单
    var condition = {
        ConditionType: ORDER_CONDITION_TYPE_TP,
        TpTriggerPrice: 65000,
        TpOrderPrice: 65000
    }
    var id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, condition)
    Sleep(1000)

    // 参数id为条件单号码，需填入你想要查询的条件单的号码
    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():
    # 创建止盈条件单
    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"])

    rust
    
    
fn main() {
    // 创建止盈条件单
    let condition = OrderCondition {
        ConditionType: ORDER_CONDITION_TYPE_TP,
        TpTriggerPrice: 65000.0,
        TpOrderPrice: 65000.0,
        ..Default::default()
    };
    let id = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, &condition).unwrap();
    Sleep(1000);

    // 参数id为条件单号码，需填入你想要查询的条件单的号码
    let order = exchange.GetConditionOrder(&id).unwrap();
    Log!("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount,
        "Status:", order.Status, "Type:", order.Type, "Condition:", order.Condition);
}

    c++
    
    
void main() {
    // 创建止盈条件单
    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);
}

返回值

参数

参考

备注

部分交易所不支持exchange.GetConditionOrder()函数。

返回的条件单结构包含触发条件、触发价格、订单状态等信息。

条件单状态包括：未触发、已触发、已取消等，具体的状态值由交易所而定。

exchange.GetConditionOrders

exchange.GetConditionOrders()函数用于获取未完成的条件单（尚未触发或尚未取消的条件单）。

    
    
    
exchange.GetConditionOrders()

    
    
    
exchange.GetConditionOrders(symbol)

示例

• 使用现货交易所对象创建多个条件单，然后查询未完成的条件单信息。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 创建多个条件单
      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)
  
      // 查询所有未完成条件单
      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():
      # 创建多个条件单
      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)
  
      # 查询所有未完成条件单
      orders = exchange.GetConditionOrders()
      Log("Pending condition orders count:", len(orders))
      for i in range(len(orders)):
          Log("Condition order", i+1, ":", orders[i])
  

  
      rust
      
      
  fn main() {
      // 创建多个条件单
      let condition1 = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 65000.0,
          TpOrderPrice: 65000.0,
          ..Default::default()
      };
      let _ = exchange.CreateConditionOrder("BTC_USDT", "sell", 0.01, &condition1);
  
      let condition2 = OrderCondition {
          ConditionType: ORDER_CONDITION_TYPE_TP,
          TpTriggerPrice: 3200.0,
          TpOrderPrice: 3200.0,
          ..Default::default()
      };
      let _ = exchange.CreateConditionOrder("ETH_USDT", "sell", 0.1, &condition2);
      Sleep(1000);
  
      // 查询所有未完成条件单
      let orders = exchange.GetConditionOrders(None).unwrap();
      Log!("Pending condition orders count:", orders.len());
      for i in 0..orders.len() {
          Log!("Condition order", i + 1, ":", orders[i]);
      }
  }
  

  
      c++
      
      
  void main() {
      // 创建多个条件单
      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);
  
      // 查询所有未完成条件单
      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]);
      }
  }
  

• 查询指定交易对的未成交条件单。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 查询 BTC_USDT 交易对的未成交条件单
      var orders = exchange.GetConditionOrders("BTC_USDT")
      Log("BTC_USDT pending condition orders:", orders)
  }
  

  
      python
      
      
  def main():
      # 查询 BTC_USDT 交易对的未成交条件单
      orders = exchange.GetConditionOrders("BTC_USDT")
      Log("BTC_USDT pending condition orders:", orders)
  

  
      rust
      
      
  fn main() {
      // 查询 BTC_USDT 交易对的未成交条件单
      let orders = exchange.GetConditionOrders("BTC_USDT");
      Log!("BTC_USDT pending condition orders:", orders);
  }
  

  
      c++
      
      
  void main() {
      // 查询 BTC_USDT 交易对的未成交条件单
      auto orders = exchange.GetConditionOrders("BTC_USDT");
      Log("BTC_USDT pending condition orders:", orders);
  }
  

返回值

参数

参考

备注

在GetConditionOrders函数中，symbol参数的使用场景归纳如下：

在GetConditionOrders函数中，期货交易所对象的查询维度范围归纳如下：

当交易所对象exchange所代表的账户在查询范围内或指定的交易品种上没有未完成条件单时，调用该函数将返回空数组，即：[]。

条件单功能的支持情况取决于具体交易所，部分交易所可能不支持条件单功能。

exchange.GetHistoryConditionOrders

exchange.GetHistoryConditionOrders()函数用于获取当前交易对、合约的历史条件单（包括已触发、已取消、已过期的条件单），并支持指定具体的交易品种。

    
    
    
exchange.GetHistoryConditionOrders()

    
    
    
exchange.GetHistoryConditionOrders(symbol)

    
    
    
exchange.GetHistoryConditionOrders(symbol, since)

    
    
    
exchange.GetHistoryConditionOrders(symbol, since, limit)

    
    
    
exchange.GetHistoryConditionOrders(since)

    
    
    
exchange.GetHistoryConditionOrders(since, limit)

示例

• 查询历史条件单，返回的结果按时间升序排列。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var historyConditionOrders = exchange.GetHistoryConditionOrders()
      Log("Historical condition orders count:", historyConditionOrders.length)
  
      // 遍历并显示，订单按 Time 属性升序排列
      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))
  
      # 遍历并显示，订单按 Time 属性升序排列
      for i in range(len(historyConditionOrders)):
          Log("Order", i+1, "Created at:", historyConditionOrders[i]["Time"],
              "ID:", historyConditionOrders[i]["Id"],
              "Status:", historyConditionOrders[i]["Status"])
  

  
      rust
      
      
  fn main() {
      let historyConditionOrders = exchange.GetHistoryConditionOrders(None, None, None).unwrap();
      Log!("Historical condition orders count:", historyConditionOrders.len());
  
      // 遍历并显示，订单按 Time 属性升序排列
      for i in 0..historyConditionOrders.len() {
          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());
  
      // 遍历并显示，订单按 Time 属性升序排列
      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);
      }
  }
  

• 查询指定交易对的历史条件单，并限制返回的数量。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 查询BTC_USDT交易对最近的10条历史条件单
      var historyConditionOrders = exchange.GetHistoryConditionOrders("BTC_USDT", 0, 10)
      Log("BTC_USDT historical condition orders:", historyConditionOrders)
  }
  

  
      python
      
      
  def main():
      # 查询BTC_USDT交易对最近的10条历史条件单
      historyConditionOrders = exchange.GetHistoryConditionOrders("BTC_USDT", 0, 10)
      Log("BTC_USDT historical condition orders:", historyConditionOrders)
  

  
      rust
      
      
  fn main() {
      // 查询BTC_USDT交易对最近的10条历史条件单
      let historyConditionOrders = exchange.GetHistoryConditionOrders("BTC_USDT", 0, 10);
      Log!("BTC_USDT historical condition orders:", historyConditionOrders);
  }
  

  
      c++
      
      
  void main() {
      // 查询BTC_USDT交易对最近的10条历史条件单
      auto historyConditionOrders = exchange.GetHistoryConditionOrders("BTC_USDT", 0, 10);
      Log("BTC_USDT historical condition orders:", historyConditionOrders);
  }
  

• 按时间范围查询历史条件单。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 查询从指定时间戳开始的历史条件单
      var startTime = new Date("2024-01-01").getTime()
      var historyConditionOrders = exchange.GetHistoryConditionOrders(startTime, 50)
      Log("Historical condition orders since:", historyConditionOrders)
  }
  

  
      python
      
      
  def main():
      # 查询从指定时间戳开始的历史条件单
      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)
  

  
      rust
      
      
  fn main() {
      // 查询从指定时间戳开始的历史条件单
      let startTime: i64 = 1704067200000;  // 2024-01-01的时间戳
      // Rust中symbol参数传None表示当前交易对
      let historyConditionOrders = exchange.GetHistoryConditionOrders(None, startTime, 50);
      Log!("Historical condition orders since:", historyConditionOrders);
  }
  

  
      c++
      
      
  void main() {
      // 查询从指定时间戳开始的历史条件单
      auto startTime = 1704067200000;  // 2024-01-01的时间戳
      // C++ 中 symbol 参数不可省略，传 "" 表示当前交易对
      auto historyConditionOrders = exchange.GetHistoryConditionOrders("", startTime, 50);
      Log("Historical condition orders since:", historyConditionOrders);
  }
  

返回值

参数

参考

备注

• 不指定symbol、since、limit参数时，默认查询当前交易对、合约的历史条件单，即查询距离当前时间最近的一定范围内的历史条件单，查询范围取决于交易所接口的单次查询范围。

• 指定symbol参数时，查询所设置交易品种的历史条件单。

• 指定since参数时，以since时间戳为起始时间，向当前时间方向查询。

• 指定limit参数时，在查询到足够条数后返回。

• 该函数仅支持提供历史条件单查询接口的交易所。

历史条件单包括：已触发（转为普通订单）、已取消、已过期等状态的条件单。

返回的历史条件单数组按订单创建时间（Time属性）升序排列，即时间最早的订单位于数组前面，时间最晚的订单位于数组后面。

对条件单功能的支持情况取决于具体的交易所，部分交易所可能不支持条件单功能或历史条件单查询功能。

exchange.SetPrecision

exchange.SetPrecision()函数用于设置exchange交易所对象的价格与下单量的精度，设置后系统会自动忽略数据中超出精度的多余部分。

    
    
    
exchange.SetPrecision(pricePrecision, amountPrecision)

示例

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

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

    rust
    
    
fn main() {
    // 设置价格小数位精度为2位，下单量小数位精度为3位
    exchange.SetPrecision(2, 3);
}

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

参数

参考

备注

回测系统不支持该函数，回测系统的数值精度由系统自动处理。

exchange.SetRate

设置交易所对象当前的汇率。

    
    
    
exchange.SetRate(rate)

示例

    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)

    rust
    
    
fn main() {
    Log!(exchange.GetTicker(None));
    // 设置汇率转换
    exchange.SetRate(7);
    Log!(exchange.GetTicker(None));
    // 设置为 1，不转换
    exchange.SetRate(1);
}

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

参数

参考

备注

如果使用 exchange.SetRate() 函数设置了汇率值（例如设置为 7），那么当前 exchange 交易所对象所代表交易所的行情、深度、下单价格等所有价格信息，都会被乘以所设置的汇率 7 进行转换。

例如，exchange 是以美元为计价货币的交易所。执行 exchange.SetRate(7) 之后，实盘中的所有价格都会被乘以 7，转换为接近 CNY 计价的价格。

exchange.IO

exchange.IO()函数用于调用交易所对象相关的其它接口。

    
    
    
exchange.IO(k, ...args)

示例

• 使用 "api" 模式调用 OKX 期货批量下单接口，并通过 raw 参数传递 JSON 格式的订单数据：

  • javascript
  • python
  • rust
  • 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"}
      ]
  
      // 调用 exchange.IO 直接访问交易所批量下单接口
      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)
  

  
      rust
      
      
  fn main() {
      // Rust无JSON序列化，直接用原始字符串构造订单数组
      let 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"}
      ]"#;
  
      // 调用 exchange.IO 直接访问交易所批量下单接口，多参数以元组传入
      let ret = exchange.IO(("api", "POST", "/api/v5/trade/batch-orders", "", 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);
  }
  

• params参数中的键值为字符串类型时，需要使用单引号将参数值包裹起来：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  var amount = 1
  var price = 10
  var basecurrency = "ltc"
  function main () {
      // 注意 amount.toString() 和 price.toString() 左边右边都有一个 ' 字符
      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)
  

  
      rust
      
      
  fn main() {
      let amount = 1;
      let price = 10;
      let basecurrency = "ltc";
      // 注意 amount 和 price 参数值的左边右边都有一个 ' 字符
      let message = format!("symbol={}&amount='{}'&price='{}'&side=buy&type=limit", basecurrency, amount, price);
      let 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 = str_format("symbol=%s&amount=\"%.1f\"&price=\"%.1f\"&side=buy&type=limit", basecurrency, amount, price);
      auto id = exchange.IO("api", "POST", "/v1/order/new", message);
  }
  

• resource参数支持传入完整的URL：

  • javascript
  • python
  • rust
  • 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)
  

  
      rust
      
      
  fn main() {
      let 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);
  }
  

• 不使用raw参数的GET请求：

  • javascript
  • python
  • rust
  • 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)
  

  
      rust
      
      
  fn main() {
      let 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);
  }
  

• 运行时切换交易对：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 例如，实盘启动时交易所对象当前的交易对为BTC_USDT，打印当前交易对的行情
      Log(exchange.GetTicker())
      // 将交易对切换为LTC_BTC
      exchange.IO("currency", "LTC_BTC")
      Log(exchange.GetTicker())
  }
  

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

  
      rust
      
      
  fn main() {
      // 例如，实盘启动时交易所对象当前的交易对为BTC_USDT，打印当前交易对的行情
      Log!(exchange.GetTicker(None));
      // 将交易对切换为LTC_BTC
      let _ = exchange.IO(("currency", "LTC_BTC"));
      Log!(exchange.GetTicker(None));
  }
  

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

• 切换交易所接口基地址：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main () {
      // exchanges[0]即实盘创建时添加的第一个交易所对象
      exchanges[0].IO("base", "https://api.huobi.pro")
  }

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

  
      rust
      
      
  fn main() {
      // exchanges[0]即实盘创建时添加的第一个交易所对象
      let _ = exchanges[0].IO(("base", "https://api.huobi.pro"));
  }
  

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

• 通过"mbase"切换行情接口基地址（以Bitfinex为例）：

  • javascript
  • python
  • rust
  • 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")
  

  
      rust
      
      
  fn main() {
      exchange.SetBase("https://api.bitfinex.com");
      let _ = 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");
  }
  

• 切换模拟盘/实盘环境（以OKX期货为例）：

  • javascript
  • python
  • rust
  • 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)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("simulate", true));    // Switch to demo trading environment
      // ... trading logic ...
      let _ = exchange.IO(("simulate", false));   // Switch back to live trading environment
  }
  

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

• 切换合约保证金模式与持仓模式（以币安期货为例）：

  • javascript
  • python
  • rust
  • 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)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("dual", true));    // Switch to hedge mode (dual position)
      let _ = exchange.IO(("dual", false));   // Switch to one-way mode
  
      let _ = exchange.SetContractType("swap");
      let _ = exchange.IO(("cross", true));    // Switch to cross margin
      let _ = exchange.IO(("cross", false));   // Switch to isolated margin
  }
  

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

• 切换统一账户模式（以币安期货为例）：

  • javascript
  • python
  • rust
  • 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)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("unified", true));   // Switch to unified account mode
      let _ = exchange.IO(("unified", false));  // Switch to normal mode
  }
  

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

• 设置自成交预防模式（以币安为例）：

  • javascript
  • python
  • rust
  • 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")
  

  
      rust
      
      
  fn main() {
      // "NONE" means disable STP mode, other parameters: "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"
      let _ = exchange.IO(("selfTradePreventionMode", "NONE"));
  }
  

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

• Futures_edgeX计算订单Hash并签名：

  • javascript
  • python
  • rust
  • 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)
  

  
      rust
      
      
  fn main() {
      let strJson = r#"{
          "assetIdSynthetic":    "0x4554482d3900000000000000000000",
          "assetIdCollateral":   "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "assetIdFee":          "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
          "isBuyingSynthetic":   true,
          "amountSynthetic":     10000000,
          "amountCollateral":    13020000,
          "amountFee":           6250,
          "nonce":               676432751,
          "accountID":           601416704693633632,
          "expirationTimestamp": 484831
      }"#;
      let signature = exchange.IO(("calcOrderHashAndSign", strJson));
      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模式限流 - 限制GetTicker每秒最多调用10次，超出限制时返回null：

  • javascript
  • python
  • rust
  • 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")
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("rate", "GetTicker", 10, "1s"));
  
      for _i in 0..20 {
          // 超出限制时GetTicker返回Err
          match exchange.GetTicker("BTC_USDT") {
              Ok(ticker) => Log!("Ticker:", ticker.Last),
              Err(_) => Log!("Rate limit exceeded"),
          }
      }
  }
  

  
      c++
      
      
  // C++暂不支持

• rate模式限流 - 使用"delay"参数，超出限制时自动等待而非返回null：

  • javascript
  • python
  • rust
  • 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"])
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("rate", "GetTicker", 10, "1s", "delay"));
  
      for i in 0..20 {
          let ticker = exchange.GetTicker("BTC_USDT").unwrap();
          Log!("Call", i + 1, "Ticker:", ticker.Last);
      }
  }
  

  
      c++
      
      
  // C++暂不支持

• 多个函数共享限流额度：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // GetTicker 和 GetDepth 共享限流额度，合计每秒最多调用 10 次
      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"))
  

  
      rust
      
      
  fn main() {
      // GetTicker 和 GetDepth 共享限流额度，合计每秒最多调用 10 次
      let _ = exchange.IO(("rate", "GetTicker,GetDepth", 10, "1s"));
  
      for i in 0..20 {
          if i % 2 == 0 {
              Log!("Ticker:", exchange.GetTicker("BTC_USDT"));
          } else {
              Log!("Depth:", exchange.GetDepth("BTC_USDT"));
          }
      }
  }
  

  
      c++
      
      
  // C++暂不支持

• 使用通配符统一限制所有 API 的调用频率：

  • javascript
  • python
  • rust
  • 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)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("rate", "*", 100, "1m"));
  
      for i in 0..10 {
          let _ = exchange.GetTicker("BTC_USDT");
          let _ = exchange.GetDepth("BTC_USDT");
          let _ = exchange.GetAccount();
          Log!("Round", i + 1, "completed");
          Sleep(1000);
      }
  }
  

  
      c++
      
      
  // C++暂不支持

• quota 模式 - 严格按时间窗口对齐限流：

  • javascript
  • python
  • rust
  • 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)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("quota", "GetTicker", 3, "1s"));
  
      for _i in 0..10 {
          match exchange.GetTicker("BTC_USDT") {
              Ok(ticker) => Log!(_D(None), "Ticker:", ticker.Last),
              Err(_) => Log!(_D(None), "Quota exceeded, waiting for next window"),
          }
          Sleep(100);
      }
  }
  

  
      c++
      
      
  // C++暂不支持

• quota 模式 - 日内配额，每天于指定时间重置：

  • javascript
  • python
  • rust
  • 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)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("quota", "GetTicker", 1000, "@0815"));
  
      let mut count = 0;
      loop {
          match exchange.GetTicker("BTC_USDT") {
              Ok(ticker) => {
                  count += 1;
                  Log!("Call count:", count, "Ticker:", ticker.Last);
              }
              Err(_) => {
                  Log!("Daily quota exceeded, waiting for reset at 08:15");
                  Sleep(60000);  // Wait 1 minute
              }
          }
          Sleep(1000);
      }
  }
  

  
      c++
      
      
  // C++暂不支持

• 组合使用多个限流规则：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      exchange.IO("rate", "GetTicker", 10, "1s")      // GetTicker 每秒 10 次
      exchange.IO("rate", "GetDepth", 5, "1s")        // GetDepth 每秒 5 次
      exchange.IO("rate", "CreateOrder", 2, "1s")     // CreateOrder 每秒 2 次
      exchange.IO("quota", "*", 1000, "@0000")        // 所有 API 每天 00:00 重置，上限 1000 次
  
      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 次
      exchange.IO("rate", "GetDepth", 5, "1s")        # GetDepth 每秒 5 次
      exchange.IO("rate", "CreateOrder", 2, "1s")     # CreateOrder 每秒 2 次
      exchange.IO("quota", "*", 1000, "@0000")        # 所有 API 每天 00:00 重置，上限 1000 次
  
      Log("Rate limits configured successfully")
  
      for i in range(5):
          exchange.GetTicker("BTC_USDT")
          exchange.GetDepth("BTC_USDT")
          Sleep(200)
  

  
      rust
      
      
  fn main() {
      let _ = exchange.IO(("rate", "GetTicker", 10, "1s"));      // GetTicker 每秒 10 次
      let _ = exchange.IO(("rate", "GetDepth", 5, "1s"));        // GetDepth 每秒 5 次
      let _ = exchange.IO(("rate", "CreateOrder", 2, "1s"));     // CreateOrder 每秒 2 次
      let _ = exchange.IO(("quota", "*", 1000, "@0000"));        // 所有 API 每天 00:00 重置，上限 1000 次
  
      Log!("Rate limits configured successfully");
  
      for _i in 0..5 {
          let _ = exchange.GetTicker("BTC_USDT");
          let _ = exchange.GetDepth("BTC_USDT");
          Sleep(200);
      }
  }
  

  
      c++
      
      
  // C++ 暂不支持

返回值

参数

参考

备注

一、直接调用交易所API（"api"模式）

            javascript
            
            
exchange.IO("api", httpMethod, resource, params, raw)

用于调用交易所未封装的原生API接口。FMZ会自动处理签名验证，您只需填写请求参数即可。

调用失败时返回空值，且该模式仅支持实盘。

二、运行时切换交易对（"currency"模式）

            javascript
            
            
exchange.IO("currency", "ETH_USDT")

用于在运行时动态切换交易对，交易对格式为大写字母加下划线分隔。此指令等同于exchange.SetCurrency。

回测模式下仅支持现货，且只能切换至相同计价币种的交易对。期货切换交易对后，需再次调用exchange.SetContractType()。

三、切换基地址（"base" / "mbase"模式）

• "base"：切换交易接口的基地址，等同于exchange.SetBase()。
• "mbase"：切换行情接口的基地址，适用于行情与交易采用不同域名的交易所。

四、通用交易模式指令

以下指令在多个交易所中通用，各交易所的具体支持情况请参见第五节的说明。

五、各交易所IO指令

所有交易所均支持"api"和"currency"指令，下方仅列出各交易所的特有指令。

现货交易所

Binance（币安）

OKX（欧易）

Huobi（火币）

Bybit

Gate.io

Bitget

CoinEx

WOO