JavaScript多线程

JavaScript策略可以用threading对象创建真正并行执行的线程，并用消息、共享字典、锁等对象在线程之间通信。本页说明怎么选用、怎么组织线程代码；各函数的参数和返回值见语法手册Threads。

先选对工具

只是并发几个请求时，exchange.Go()更简单，也不需要处理线程间的数据传递。本页的threading对象只适用于JavaScript策略，Python、Rust策略请使用exchange.Go()。

回测系统中可以调用这些函数，但线程实际是按顺序执行的，只用于保证代码在回测中能运行。

线程运行在隔离的环境中

传给threading.Thread()的函数在一个独立的JavaScript环境中执行，这是写线程代码时最需要注意的一点：

• 线程函数不能引用外部的变量和闭包，也不能调用策略里自定义的其它函数。需要的数据通过threading.Thread(func, arg1, arg2, ...)的参数传入。
• 普通对象、数组作为参数时是深拷贝：线程里修改它不影响其它线程。需要多个线程看到同一份数据时，使用threading.Dict()创建的字典。
• 函数也可以作为参数传入；threading.Thread()还支持传入函数源码字符串，用于在线程中加载外部库。
• 线程里可以直接调用平台的API函数，如exchange.GetTicker()、Log()。
• 线程函数的返回值通过join()取回：t.join().ret。

线程之间怎样交换数据

线程收到消息时也会产生事件，可以用线程对象的eventLoop统一等待消息和其它事件。

线程的生命周期

• t.join()等待线程结束并取回返回值，可以设置超时；t.terminate()强制结束线程。
• 线程结束且不再被引用时，资源会自动回收，不必为了释放资源调用join()。持续引用、无法回收的线程累计超过2000个时会报错。
• threading.pending()返回正在运行的线程数（包括主线程）。
• 实盘停止时所有线程一起结束。peekMessage()、join()、锁和事件的等待都会被停止打断。

在策略内提供服务

threading.Serve(地址, 处理函数, ...参数)在策略进程内启动HTTP（含WebSocket）或TCP服务，每个请求或连接在独立的线程中调用处理函数，返回Server对象（addr()取实际监听地址，close()关闭）。处理函数与线程函数一样运行在隔离环境中，需要的数据通过参数传入，常用threading.Dict()与主线程共享状态。地址写法、ctx对象的方法见Serve。

旧的全局函数__Serve()仍可使用，它只返回监听地址字符串，新代码请使用threading.Serve()。

示例

示例

• 多个线程并行计算，主线程汇总结果

  每个线程拉取一个交易对的K线并计算均线，结果通过返回值交给主线程。注意交易对通过参数传入，线程函数里没有引用外部变量。

  
      javascript
      
      
  function main() {
      var symbols = ["BTC_USDT", "ETH_USDT", "SOL_USDT"]
      var threads = []
      for (var i = 0; i < symbols.length; i++) {
          threads.push(threading.Thread(function(symbol, period) {
              // 在线程中运行：只能使用参数和平台API
              var records = exchange.GetRecords(symbol, period)
              if (!records || records.length < 20) {
                  return null
              }
              var ma = TA.MA(records, 20)
              return {symbol: symbol, close: records[records.length - 1].Close, ma20: ma[ma.length - 1]}
          }, symbols[i], PERIOD_H1))
      }
      for (var i = 0; i < threads.length; i++) {
          var r = threads[i].join().ret
          if (r) {
              Log(r.symbol, "收盘价:", r.close, "MA20:", r.ma20)
          }
      }
  }
  

• 后台线程采集行情，主线程读取与下发指令

  后台线程把最新价写进共享字典，并把异常通过消息报告给主线程；主线程通过消息通知后台线程退出。

  
      javascript
      
      
  function main() {
      var shared = threading.Dict()
      var worker = threading.Thread(function(dict, symbol) {
          while (true) {
              // 读取主线程发来的指令，-1 表示不阻塞
              var cmd = threading.currentThread().peekMessage(-1)
              if (cmd == "stop") {
                  break
              }
              var ticker = exchange.GetTicker(symbol)
              if (ticker) {
                  dict.set("last", ticker.Last)
                  dict.set("time", ticker.Time)
              } else {
                  threading.mainThread().postMessage("行情获取失败: " + GetLastError())
              }
              Sleep(1000)
          }
          return "worker exited"
      }, shared, "BTC_USDT")
  
      for (var i = 0; i < 10; i++) {
          // 最多等 1 秒后台线程的消息
          var msg = threading.currentThread().peekMessage(1000)
          if (msg) {
              Log("后台线程报告:", msg)
          }
          LogStatus("最新价:", shared.get("last"), "时间:", _D(shared.get("time")))
      }
      worker.postMessage("stop")
      Log(worker.join().ret)
  }
  

• 用threading.Serve提供状态查询接口

  主线程把状态写进共享字典，HTTP处理函数从参数取到同一个字典并返回JSON。

  
      javascript
      
      
  function main() {
      var state = threading.Dict()
      var server = threading.Serve("http://127.0.0.1:8088", function(ctx, st) {
          if (ctx.path() == "/status") {
              ctx.setHeader("Content-Type", "application/json")
              ctx.write(JSON.stringify({last: st.get("last"), updated: st.get("updated")}))
          } else {
              ctx.setStatus(404)
          }
      }, state)
      Log("服务地址:", server.addr())
  
      while (true) {
          var ticker = exchange.GetTicker("BTC_USDT")
          if (ticker) {
              state.set("last", ticker.Last)
              state.set("updated", _D())
          }
          Sleep(3000)
      }
  }
  

参考

策略实盘间通信

每个实盘都有一个频道，频道ID就是实盘ID。实盘用SetChannelData()在自己的频道上发布数据，其它实盘用GetChannelData(实盘ID)读取。数据经平台服务端转发，可以跨托管者、跨服务器传递。

频道保存的是最新状态，不是消息队列：每次发布都覆盖上一次的数据，订阅端每次读到的都是当前最新的一份。需要历史记录时由订阅端自己保存。

常见用途：

• 主从协同：主策略分析行情并发布信号，多个从策略读取信号在各自账户上执行。
• 状态监控：各策略发布运行状态，监控实盘汇总展示或告警。
• 数据共享：一个实盘计算指标、发布结果，其它实盘直接使用，避免重复计算。

使用要点

• 首次读取即订阅：对某个频道第一次调用GetChannelData()时完成订阅并返回空值（null/None），之后服务端把该频道的更新推送到本实盘，再调用就能读到最新数据。订阅端应在启动时就开始读取，并处理空值。
• 订阅上限：每个实盘最多订阅10个不同的频道（包括下面的UUID频道）。超出时该次调用返回空值，并记录一条错误日志channel subscriber exceed limit。
• **数据格式**：JavaScript、Python的SetChannelData()可以传入任何可以JSON序列化的数据，订阅端读到的是解析后的对象。数据不变时不会重复发送。数据大小限制见SetChannelData。
• Rust：SetChannelData(string)只接受字符串，需要自己拼好JSON文本；GetChannelData()没有频道参数，不能指定要读取的频道，因此不能订阅其它实盘或UUID频道。Rust策略适合作为广播端，订阅端请使用JavaScript或Python。
• **跨平台推送**：外部系统（如TradingView告警、自建程序）可以通过扩展API的method=pub向指定实盘推送一个以32位UUID标识的频道数据，实盘用GetChannelData(UUID)读取，具体方法见SetChannelData、GetChannelData。
• 实盘功能：频道通信用于实盘之间，回测时不要依赖它。当前实盘ID可以用_G()获取。
• 不要在频道中传递密钥等敏感信息。

基本用法

示例

• 广播端：发布行情摘要

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main() {
      var robotId = _G()  // 当前实盘ID，也就是本实盘的频道ID
      var updateId = 0
  
      while (true) {
          var ticker = exchange.GetTicker("BTC_USDT")
          if (ticker) {
              // 发布最新状态，覆盖上一次的数据
              SetChannelData({
                  robotId: robotId,
                  updateId: ++updateId,
                  timestamp: Date.now(),
                  symbol: "BTC_USDT",
                  lastPrice: ticker.Last
              })
              LogStatus("频道", robotId, "第", updateId, "次发布，最新价:", ticker.Last)
          }
          Sleep(60000)  // 每分钟发布一次
      }
  }
  

  
      python
      
      
  import time
  
  def main():
      robotId = _G()  # 当前实盘ID，也就是本实盘的频道ID
      updateId = 0
  
      while True:
          ticker = exchange.GetTicker("BTC_USDT")
          if ticker:
              updateId += 1
              # 发布最新状态，覆盖上一次的数据
              SetChannelData({
                  "robotId": robotId,
                  "updateId": updateId,
                  "timestamp": int(time.time() * 1000),
                  "symbol": "BTC_USDT",
                  "lastPrice": ticker["Last"]
              })
              LogStatus("频道", robotId, "第", updateId, "次发布，最新价:", ticker["Last"])
          Sleep(60000)  # 每分钟发布一次
  

  
      rust
      
      
  fn main() {
      let robotId = _G!();  // 当前实盘ID，也就是本实盘的频道ID
      let mut updateId = 0;
  
      loop {
          if let Ok(ticker) = exchange.GetTicker("BTC_USDT") {
              updateId += 1;
              // Rust 的 SetChannelData 只接受字符串，自己拼 JSON 文本
              let state = format!(
                  r#"{{"robotId": "{}", "updateId": {}, "timestamp": {}, "symbol": "BTC_USDT", "lastPrice": {}}}"#,
                  robotId, updateId, Unix() * 1000, ticker.Last
              );
              SetChannelData(&state);
              LogStatus!("频道", robotId, "第", updateId, "次发布，最新价:", ticker.Last);
          }
          Sleep(60000);  // 每分钟发布一次
      }
  }
  

• 订阅端：读取两个频道

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main() {
      // 要订阅的实盘ID（按实际情况修改）
      var channels = ["632799", "632800"]
  
      while (true) {
          var msg = ""
          for (var i = 0; i < channels.length; i++) {
              // 第一次调用完成订阅并返回 null，之后返回最新数据
              var state = GetChannelData(channels[i])
              if (state) {
                  msg += "频道 " + channels[i] + "：#" + state.updateId + " " + _D(state.timestamp) + " 最新价 " + state.lastPrice + "\n"
              } else {
                  msg += "频道 " + channels[i] + "：等待数据\n"
              }
          }
          LogStatus(msg)
          Sleep(5000)
      }
  }
  

  
      python
      
      
  def main():
      # 要订阅的实盘ID（按实际情况修改）
      channels = ["632799", "632800"]
  
      while True:
          msg = ""
          for ch in channels:
              # 第一次调用完成订阅并返回 None，之后返回最新数据
              state = GetChannelData(ch)
              if state:
                  msg += "频道 {}：#{} {} 最新价 {}\n".format(ch, state["updateId"], _D(state["timestamp"]), state["lastPrice"])
              else:
                  msg += "频道 {}：等待数据\n".format(ch)
          LogStatus(msg)
          Sleep(5000)
  

  
      rust
      
      
  // Rust 的 GetChannelData() 没有频道参数，不能订阅其它实盘的频道
  

• 场景：主从策略协同

  主策略计算均线交叉信号并发布；从策略读取信号，在信号变化时下单。

  主策略（发布信号）

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main() {
      while (true) {
          var records = exchange.GetRecords("BTC_USDT")
          if (records && records.length >= 21) {
              var ma5 = TA.MA(records, 5)
              var ma20 = TA.MA(records, 20)
              var n = records.length
              var signal = "HOLD"
              if (ma5[n - 1] > ma20[n - 1] && ma5[n - 2] <= ma20[n - 2]) {
                  signal = "BUY"
              } else if (ma5[n - 1] < ma20[n - 1] && ma5[n - 2] >= ma20[n - 2]) {
                  signal = "SELL"
              }
              SetChannelData({
                  timestamp: Date.now(),
                  symbol: "BTC_USDT",
                  signal: signal,
                  price: records[n - 1].Close
              })
              LogStatus("当前信号:", signal, "价格:", records[n - 1].Close)
          }
          Sleep(60000)
      }
  }
  

  
      python
      
      
  import time
  
  def main():
      while True:
          records = exchange.GetRecords("BTC_USDT")
          if records and len(records) >= 21:
              ma5 = TA.MA(records, 5)
              ma20 = TA.MA(records, 20)
              signal = "HOLD"
              if ma5[-1] > ma20[-1] and ma5[-2] <= ma20[-2]:
                  signal = "BUY"
              elif ma5[-1] < ma20[-1] and ma5[-2] >= ma20[-2]:
                  signal = "SELL"
              SetChannelData({
                  "timestamp": int(time.time() * 1000),
                  "symbol": "BTC_USDT",
                  "signal": signal,
                  "price": records[-1]["Close"]
              })
              LogStatus("当前信号:", signal, "价格:", records[-1]["Close"])
          Sleep(60000)
  

  
      rust
      
      
  fn main() {
      loop {
          if let Ok(records) = exchange.GetRecords("BTC_USDT", None, None) {
              let n = records.len();
              if n >= 21 {
                  let ma5 = TA.MA(&records, 5);
                  let ma20 = TA.MA(&records, 20);
                  let mut signal = "HOLD";
                  if ma5[n - 1] > ma20[n - 1] && ma5[n - 2] <= ma20[n - 2] {
                      signal = "BUY";
                  } else if ma5[n - 1] < ma20[n - 1] && ma5[n - 2] >= ma20[n - 2] {
                      signal = "SELL";
                  }
                  let price = records[n - 1].Close;
                  // Rust 的 SetChannelData 只接受字符串，自己拼 JSON 文本
                  let data = format!(
                      r#"{{"timestamp": {}, "symbol": "BTC_USDT", "signal": "{}", "price": {}}}"#,
                      Unix() * 1000, signal, price
                  );
                  SetChannelData(&data);
                  LogStatus!("当前信号:", signal, "价格:", price);
              }
          }
          Sleep(60000);
      }
  }
  

• 从策略（读取信号并执行）

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main() {
      var masterId = "632799"  // 主策略的实盘ID
      var lastSignal = null
  
      while (true) {
          var data = GetChannelData(masterId)
          if (!data) {
              LogStatus("等待主策略信号...")
          } else {
              if (data.signal !== lastSignal) {
                  Log("收到新信号:", data.signal, "信号价格:", data.price)
                  var ticker = exchange.GetTicker(data.symbol)
                  if (ticker && data.signal === "BUY") {
                      exchange.CreateOrder(data.symbol, "buy", ticker.Last, 0.01)
                  } else if (ticker && data.signal === "SELL") {
                      exchange.CreateOrder(data.symbol, "sell", ticker.Last, 0.01)
                  }
                  lastSignal = data.signal
              }
              LogStatus("当前信号:", data.signal, "信号时间:", _D(data.timestamp))
          }
          Sleep(5000)
      }
  }
  

  
      python
      
      
  def main():
      masterId = "632799"  # 主策略的实盘ID
      lastSignal = None
  
      while True:
          data = GetChannelData(masterId)
          if not data:
              LogStatus("等待主策略信号...")
          else:
              if data["signal"] != lastSignal:
                  Log("收到新信号:", data["signal"], "信号价格:", data["price"])
                  ticker = exchange.GetTicker(data["symbol"])
                  if ticker and data["signal"] == "BUY":
                      exchange.CreateOrder(data["symbol"], "buy", ticker["Last"], 0.01)
                  elif ticker and data["signal"] == "SELL":
                      exchange.CreateOrder(data["symbol"], "sell", ticker["Last"], 0.01)
                  lastSignal = data["signal"]
              LogStatus("当前信号:", data["signal"], "信号时间:", _D(data["timestamp"]))
          Sleep(5000)
  

  
      rust
      
      
  // Rust 的 GetChannelData() 没有频道参数，不能读取主策略实盘的频道
  

• 场景：多策略状态监控

  各策略按上面广播端的方式发布状态，监控实盘读取所有频道，用表格展示，超过2分钟没有更新的标记为异常。

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main() {
      var monitorList = ["632799", "632800", "632801"]  // 最多10个
  
      while (true) {
          var table = {type: "table", title: "策略运行状态", cols: ["实盘ID", "状态", "最后更新", "交易对", "最新价"], rows: []}
          for (var i = 0; i < monitorList.length; i++) {
              var data = GetChannelData(monitorList[i])
              if (data) {
                  var status = Date.now() - data.timestamp < 120000 ? "运行中" : "异常"
                  table.rows.push([monitorList[i], status, _D(data.timestamp), data.symbol || "-", data.lastPrice || "-"])
              } else {
                  table.rows.push([monitorList[i], "等待数据", "-", "-", "-"])
              }
          }
          LogStatus("`" + JSON.stringify(table) + "`")
          Sleep(10000)
      }
  }
  

  
      python
      
      
  import json
  import time
  
  def main():
      monitorList = ["632799", "632800", "632801"]  # 最多10个
  
      while True:
          table = {"type": "table", "title": "策略运行状态", "cols": ["实盘ID", "状态", "最后更新", "交易对", "最新价"], "rows": []}
          for robotId in monitorList:
              data = GetChannelData(robotId)
              if data:
                  status = "运行中" if time.time() * 1000 - data["timestamp"] < 120000 else "异常"
                  table["rows"].append([robotId, status, _D(data["timestamp"]), data.get("symbol", "-"), data.get("lastPrice", "-")])
              else:
                  table["rows"].append([robotId, "等待数据", "-", "-", "-"])
          LogStatus("`" + json.dumps(table) + "`")
          Sleep(10000)
  

  
      rust
      
      
  // Rust 的 GetChannelData() 没有频道参数，不能读取其它实盘的频道
  

参考

API限流控制

交易所对API调用频率有限制，超限轻则请求被拒，重则账号被临时封禁。用exchange.IO("rate", ...)或exchange.IO("quota", ...)可以在托管者本地给标准函数设置调用频率上限：超限的调用不会发出请求。

            javascript
            
            
exchange.IO("rate" | "quota", 名字, 次数, 窗口[, "delay"])

两种模式

• rate（令牌桶）：桶容量默认等于次数，开始时是满的，之后按「次数/窗口」的速度匀速补充，每次调用消耗一个。允许短时间连续调用，长期平均不超过「次数/窗口」。次数写成"10/5"时表示每个窗口补充10次、桶容量为5，用来限制突发。
• quota（固定窗口）：每个窗口内最多调用次数次，进入下一个窗口时清零。窗口按时间纪元对齐："1s"对齐整秒，"1m"对齐整分钟，"1h"对齐整点，"1d"对齐UTC零点（即北京时间08:00）。例如12:00:00.900开始计数，到12:00:01.000就进入了新窗口。

需要严格保证「任意一个交易所计数周期内不超过N次」时用quota并让窗口与交易所的计数周期一致；只需要控制平均频率时用rate。

参数

可以限制的函数名

• GetAccount和GetAssets是同一个底层请求，写其中任何一个名字的规则对两个函数都生效。
• 通过exchange.Go()并发调用时，按实际调用的函数计数。

规则的作用范围

• 规则按交易所对象分别设置：exchanges[0]上的规则不影响exchanges[1]。
• 规则只在本次运行中有效，实盘重启后需要重新设置，通常写在main()开头。
• 同一个名字再次设置时覆盖原规则；名字传空字符串（exchange.IO("rate", "")）清空该交易所对象上的全部规则。
• 一次调用只按一条规则计数：有专属规则的函数不再计入"*"，所以"*"不能当作「所有调用的总配额」叠加在专属规则之上。

超限时的表现

默认动作下，超限的调用不发请求，按调用失败处理（JavaScript返回null，Python返回None，Rust返回Err），错误信息形如：

            
            
            
rate limit exceeded: GetTicker 10/1s
quota limit exceeded: GetTicker 10/1m
quota limit exceeded: GetRecords 2000/day (resets at 0800)

使用"delay"动作时调用会阻塞到有可用次数，日志中记录的调用时间是等待结束之后的时间。对每天清零的规则使用"delay"，最长可能等待到第二天，请谨慎使用。

示例

示例

• 默认动作：超限时调用失败

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main() {
      // GetTicker 平均每秒最多 5 次（令牌桶，容量 5）
      exchange.IO("rate", "GetTicker", 5, "1s")
  
      for (var i = 0; i < 10; i++) {
          var ticker = exchange.GetTicker("BTC_USDT")
          if (ticker) {
              Log("第", i + 1, "次成功:", ticker.Last)
          } else {
              // 超限的调用不发请求，返回 null
              Log("第", i + 1, "次被限流:", GetLastError())
          }
      }
  }
  

  
      python
      
      
  def main():
      # GetTicker 平均每秒最多 5 次（令牌桶，容量 5）
      exchange.IO("rate", "GetTicker", 5, "1s")
  
      for i in range(10):
          ticker = exchange.GetTicker("BTC_USDT")
          if ticker:
              Log("第", i + 1, "次成功:", ticker["Last"])
          else:
              # 超限的调用不发请求，返回 None
              Log("第", i + 1, "次被限流:", GetLastError())
  

  
      rust
      
      
  fn main() {
      // GetTicker 平均每秒最多 5 次（令牌桶，容量 5）
      let _ = exchange.IO(("rate", "GetTicker", 5, "1s"));
  
      for i in 0..10 {
          match exchange.GetTicker("BTC_USDT") {
              Ok(ticker) => Log!("第", i + 1, "次成功:", ticker.Last),
              // 超限的调用不发请求，返回 Err
              Err(e) => Log!("第", i + 1, "次被限流:", e),
          }
      }
  }
  

• 按交易所的限频规则分组设置

  行情和交易分别共用一条规则；交易类超限时等待而不是失败；其余没有专属规则的函数用"*"兜底。

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main() {
      // 行情：GetTicker、GetDepth 合计平均每秒 20 次
      exchange.IO("rate", "GetTicker,GetDepth", 20, "1s")
      // 交易：下单（含 Buy/Sell）、撤单合计每秒 5 次，超限时等待
      exchange.IO("rate", "CreateOrder,CancelOrder", 5, "1s", "delay")
      // 兜底：其它函数（如 GetAccount、GetPositions）合计每分钟 60 次，窗口对齐整分钟
      exchange.IO("quota", "*", 60, "1m")
  
      while (true) {
          var ticker = exchange.GetTicker("BTC_USDT")
          var depth = exchange.GetDepth("BTC_USDT")
          if (ticker && depth) {
              Log("最新价:", ticker.Last, "买一:", depth.Bids[0].Price)
          }
          Sleep(1000)
      }
  }
  

  
      python
      
      
  def main():
      # 行情：GetTicker、GetDepth 合计平均每秒 20 次
      exchange.IO("rate", "GetTicker,GetDepth", 20, "1s")
      # 交易：下单（含 Buy/Sell）、撤单合计每秒 5 次，超限时等待
      exchange.IO("rate", "CreateOrder,CancelOrder", 5, "1s", "delay")
      # 兜底：其它函数（如 GetAccount、GetPositions）合计每分钟 60 次，窗口对齐整分钟
      exchange.IO("quota", "*", 60, "1m")
  
      while True:
          ticker = exchange.GetTicker("BTC_USDT")
          depth = exchange.GetDepth("BTC_USDT")
          if ticker and depth:
              Log("最新价:", ticker["Last"], "买一:", depth["Bids"][0]["Price"])
          Sleep(1000)
  

  
      rust
      
      
  fn main() {
      // 行情：GetTicker、GetDepth 合计平均每秒 20 次
      let _ = exchange.IO(("rate", "GetTicker,GetDepth", 20, "1s"));
      // 交易：下单（含 Buy/Sell）、撤单合计每秒 5 次，超限时等待
      let _ = exchange.IO(("rate", "CreateOrder,CancelOrder", 5, "1s", "delay"));
      // 兜底：其它函数（如 GetAccount、GetPositions）合计每分钟 60 次，窗口对齐整分钟
      let _ = exchange.IO(("quota", "*", 60, "1m"));
  
      loop {
          if let (Ok(ticker), Ok(depth)) = (exchange.GetTicker("BTC_USDT"), exchange.GetDepth("BTC_USDT")) {
              Log!("最新价:", ticker.Last, "买一:", depth.Bids[0].Price);
          }
          Sleep(1000);
      }
  }
  

• 突发容量、每日配额与删除规则

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main() {
      // 平均每秒 10 次，但最多连续突发 2 次
      exchange.IO("rate", "GetDepth", "10/2", "1s")
      // 每天北京时间 08:00 清零，每天最多 2000 次
      exchange.IO("quota", "GetRecords", 2000, "@0800")
      // 窗口可以组合单位：每 1 小时 30 分钟最多 100 次
      exchange.IO("rate", "GetOrders", 100, "1h30m")
  
      // 次数传 0：删除 GetOrders 的规则
      exchange.IO("rate", "GetOrders", 0)
      // 名字传空字符串：清空本交易所对象上的全部规则
      exchange.IO("rate", "")
  }
  

  
      python
      
      
  def main():
      # 平均每秒 10 次，但最多连续突发 2 次
      exchange.IO("rate", "GetDepth", "10/2", "1s")
      # 每天北京时间 08:00 清零，每天最多 2000 次
      exchange.IO("quota", "GetRecords", 2000, "@0800")
      # 窗口可以组合单位：每 1 小时 30 分钟最多 100 次
      exchange.IO("rate", "GetOrders", 100, "1h30m")
  
      # 次数传 0：删除 GetOrders 的规则
      exchange.IO("rate", "GetOrders", 0)
      # 名字传空字符串：清空本交易所对象上的全部规则
      exchange.IO("rate", "")
  

  
      rust
      
      
  fn main() {
      // 平均每秒 10 次，但最多连续突发 2 次
      let _ = exchange.IO(("rate", "GetDepth", "10/2", "1s"));
      // 每天北京时间 08:00 清零，每天最多 2000 次
      let _ = exchange.IO(("quota", "GetRecords", 2000, "@0800"));
      // 窗口可以组合单位：每 1 小时 30 分钟最多 100 次
      let _ = exchange.IO(("rate", "GetOrders", 100, "1h30m"));
  
      // 次数传 0：删除 GetOrders 的规则
      let _ = exchange.IO(("rate", "GetOrders", 0));
      // 名字传空字符串：清空本交易所对象上的全部规则
      let _ = exchange.IO(("rate", ""));
  }
  

参考

期权交易

发明者量化交易平台支持在以下加密货币期货交易所交易期权。期权的用法与期货合约相同：用exchange.SetContractType()把合约设为期权代码（期权代码就是交易所的原生代码，各交易所写法不同），之后GetTicker()、GetDepth()等行情函数，Buy()、Sell()（下单前用exchange.SetDirection()设置交易方向）、CancelOrder()、GetPositions()等交易函数都作用于该期权合约。也可以用完整的交易品种代码直接下单，形如交易对.期权代码，例如BTC_USDT.BTC-260925-145000-C。

期权合约的盘口通常较薄：买一、卖一没有挂单时Ticker的Buy、Sell为0，从未成交的合约Last也可能为0，各交易所的处理见下文。exchange.GetMarkets()是否列出期权合约因交易所而异；不列出时，期权代码需要从交易所的接口或网页获取。

Futures_Deribit

设置期权合约后即可获取行情、下单、撤单、查询持仓。期权代码例子：BTC-13SEP24-60000-C、XRP_USDC-27SEP24-1-C，组合合约例子：BTC-CS-6SEP24-57000_57500、BTC-PCAL-20SEP24_13SEP24-55000。exchange.GetMarkets()的结果包含期权合约。

可供参考的策略代码：Deribit期权测试策略

Futures_OKX

用法与Deribit相同，交易对设置为BTC_USD等，期权代码形如BTC-USD-200626-4500-C。从未成交的期权合约，GetTicker()的Last取标记价格。exchange.GetMarkets()不列出期权合约，可以通过OKX的/api/v5/public/instruments接口查询期权合约列表，例如查询BTC期权：

            javascript
            
            
function main() {
    Log(HttpQuery("https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD"))
}

            python
            
            
import json
import urllib.request
def main():
    ret = json.loads(urllib.request.urlopen("https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD").read().decode('utf-8'))
    Log(ret)

            rust
            
            
fn main() {
    let body: String = HttpQuery("https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD", None);
    Log!(body);
}

Futures_Binance

支持币安欧式期权（USDT结算），交易对设置为BTC_USDT等，期权代码形如BTC-260925-145000-C（标的-到期日YYMMDD-行权价-C/P）。需要账户已开通期权交易。限制：

• 只支持限价单，不支持市价单、条件单和改单（exchange.ModifyOrder()）。
• 不支持exchange.SetMarginLevel()等杠杆、保证金模式设置。
• 统一账户（组合保证金）不支持期权。
• exchange.GetMarkets()不列出期权合约。

Futures_Bybit

支持两种结算的期权：

• USDC结算：交易对设置为ETH_USDC等，期权代码形如ETH-25NOV22-1375-P。
• USDT结算：交易对设置为ETH_USDT等，期权代码比USDC结算的多一段结算币后缀，形如ETH-25JUN27-2800-C-USDT。

exchange.GetMarkets()的结果包含两种结算的期权合约。Bybit期权没有K线接口，GetRecords()由成交记录合成。

Futures_Aevo

支持Aevo交易所的USDC期权，交易对设置为ETH_USDC等，期权代码形如ETH-30JUN23-1600-C。GetTicker()的Last为标记价格。Aevo没有K线接口，GetRecords()由成交记录合成，合约没有成交时为空。exchange.GetMarkets()的结果包含期权合约。

Futures_GateIO

支持Gate交易所的USDT期权，交易对设置为BTC_USDT等，期权代码形如BTC_USDT-20211130-65000-C。exchange.GetMarkets()的结果包含期权合约。账户没有开通期权时，查询订单、持仓会返回交易所的错误。

Futures_Kraken

支持Kraken期货的期权，交易对设置为ETH_USD等，期权代码形如OF_ETHUSD_261225_4000_C（OF_、标的与计价币、到期日YYMMDD、行权价、C/P），代码中的标的与计价币必须与交易对一致，BTC在代码中写作XBT（如OF_XBTUSD_...）。

• Kraken没有期权合约列表接口，exchange.GetMarkets()不包含期权合约，期权代码需要从Kraken网页获取。
• GetTicker()的Last取标记价格，Buy、Sell、High、Low为0，原始数据Info中有隐含波动率、希腊值等字段。
• 行情、K线、订单、持仓、历史订单的查询可用；期权下单与期货合约走同一个下单接口，尚未经过实盘验证。
• 期权没有资金费率，不支持exchange.SetMarginLevel()。

参考

Web3

在去中心化交易所Uniswap、PancakeSwap上兑换代币，请使用Uniswap交易所对象，见Uniswap与PancakeSwap；查询链上数据、调用智能合约、发送自定义交易，请使用Web3交易所对象，它支持以太坊等EVM兼容链和波场。

    javascript
    
    
function main() {
    var symbol = "ETH_USDC"
    exchange.IO("slippage", 0.003)   // 市价单滑点 0.3%

    var t = exchange.GetTicker(symbol)
    Log("买一:", t.Buy, "卖一:", t.Sell)

    // 只询价：卖出 0.1 ETH 的最优路径
    var r = exchange.IO("route", symbol, "sell", 0.1)
    Log("最优路径:", r.best, "价格:", r.price)

    // 链上模拟一遍，不花 gas
    if (!exchange.IO("simulate", symbol, "sell", 0.1)) {
        Log("模拟失败:", GetLastError())
        return
    }

    // 市价卖出 0.1 ETH，订单 ID 是交易哈希
    var id = exchange.CreateOrder(symbol, "sell", -1, 0.1)
    if (!id) {
        Log("下单失败:", GetLastError())
        return
    }
    while (true) {
        var o = exchange.GetOrder(id)
        if (o && o.Status != ORDER_STATE_PENDING) {
            Log("状态:", o.Status, "成交数量:", o.DealAmount, "成交均价:", o.AvgPrice)
            break
        }
        Sleep(3000)
    }
}

            javascript
            
            
exchange.IO("api", "eth", "eth_getBalance", wallet, "latest")   // 原生币余额，链上整数（十六进制字符串）
exchange.IO("api", tokenAddress, "balanceOf", wallet)           // ERC20余额，链上整数
exchange.IO("api", tokenAddress, "decimals")                    // 代币精度

            javascript
            
            
exchange.IO("abi", poolAddress, "uniswapV3Pool")
var slot0 = exchange.IO("api", poolAddress, "slot0")

            url
            
            
https://api.etherscan.io/v2/api?chainid=1&module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45&apikey=YourApiKey

            javascript
            
            
var amount = exchange.IO("toUnits", "100", tokenAddress)                 // 100个代币换算成链上整数
var txHash = exchange.IO("api", tokenAddress, "approve", spender, amount)

    javascript
    
    
function main() {
    var usdc = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"     // 以太坊主网 USDC
    var spender = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"  // 被授权的合约，这里以 Uniswap SwapRouter02 为例
    var wallet = exchange.IO("address")

    // 查余额：标准 ERC20 方法不需要注册 ABI
    var eth = exchange.IO("fromUnits", exchange.IO("api", "eth", "eth_getBalance", wallet, "latest"), 18)
    var usdcBalance = exchange.IO("fromUnits", exchange.IO("api", usdc, "balanceOf", wallet), usdc)
    Log("ETH:", eth, "USDC:", usdcBalance)

    // 读合约：当前授权额度
    var allowance = exchange.IO("api", usdc, "allowance", wallet, spender)
    Log("当前授权:", exchange.IO("fromUnits", allowance, usdc))

    // 授权 100 USDC：先预演，再发送
    var amount = exchange.IO("toUnits", "100", usdc)
    if (!exchange.IO("call", usdc, "approve", spender, amount)) {
        Log("预演失败:", GetLastError())
        return
    }
    var txHash = exchange.IO("api", usdc, "approve", spender, amount)
    Log("交易哈希:", txHash)

    // 等待上链，最多 3 分钟
    var receipt = exchange.IO("waitReceipt", txHash, {timeout: 180000})
    if (receipt && receipt.status == 1) {
        Log("授权成功，区块:", receipt.blockNumber)
    } else if (receipt) {
        Log("交易失败:", receipt.revertReason)
    } else {
        // 未上链：可以用 speedUp 加价重发，或 cancelTx 取消
        Log("超时未上链:", GetLastError())
    }
}

            javascript
            
            
// USDT（TRC20）合约
var usdt = "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"
Log(exchange.IO("api", usdt, "balanceOf", exchange.IO("address")))   // 链上整数，USDT精度为6

            javascript
            
            
exchange.IO("encode", "address", "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t")
// 000000000000000000000000a614f803b6fd780986a42c78ec9c7f77e6ded13c
exchange.IO("encodePacked", "address", "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t")
// a614f803b6fd780986a42c78ec9c7f77e6ded13c
exchange.IO("decode", "string", "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000a5465746865722055534400000000000000000000000000000000000000000000")
// Tether USD

            javascript
            
            
var usdt = "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"
var raw = exchange.IO("api", usdt, "balanceOf", exchange.IO("address"))
Log(exchange.IO("fromUnits", raw, usdt))   // 按合约的 decimals() 换算为可读数量