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

Crypto.com

AscendEx

Gemini

Poloniex

Bitfinex

Backpack

Hyperliquid（现货）

合约交易所

Futures_Binance（币安合约）

Futures_OKX（欧易合约）

Futures_HuobiDM（火币合约）

Futures_Bybit

Futures_KuCoin

Futures_GateIO

Futures_Bitget

Futures_MEXC

Futures_BitMEX

Futures_CoinEx

Futures_WOO

Futures_Kraken

Futures_Aevo

Futures_Hyperliquid

Futures_Deepcoin

Futures_DigiFinex

Futures_ApolloX

Futures_Aster

Futures_CoinW

Futures_BitMart

Futures_Backpack

Futures_Lighter

Futures_Crypto.com

Futures_Bitfinex

Futures_edgeX

Futures_Bibox

Futures_Pionex

Futures_Phemex

Futures_WooFi

仅支持通用指令"api"和"currency"，无特有指令。

六、特殊平台IO指令

Polymarket（预测市场）

Web3（区块链）

IB（盈透证券）

Futu（富途证券）

七、API限流控制（"rate" / "quota"模式）

            javascript
            
            
exchange.IO("rate", functionNames, maxCalls, period, [behavior])
exchange.IO("quota", functionNames, maxCalls, period, [behavior])

• rate：平滑限流，不严格对齐时间窗口。
• quota：额度限流，严格对齐时间窗口。

Buy/Sell的限流遵循CreateOrder的设置；Go遵循实际并发函数的设置；IO/api仅对exchange.IO("api", ...)生效。