Dial

Used for raw Socket access, supporting the tcp, udp, tls, and unix protocols. Supports 4 mainstream messaging protocols: mqtt, nats, amqp, and kafka. Also supports connecting to databases, with available databases including: sqlite3, mysql, postgres, and clickhouse.

    
    
    
Dial(address)

    
    
    
Dial(address, timeout)

    
    
    
Dial(address, options)

Examples

• Dial function call example:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main(){
      // Dial supports the tcp://, udp://, tls://, and unix:// protocols, and accepts a parameter specifying the timeout in seconds
      var client = Dial("tls://www.baidu.com:443")
      if (client) {
          // write can take an additional numeric parameter to specify a timeout, and returns the number of bytes successfully sent
          client.write("GET / HTTP/1.1\nConnection: Closed\n\n")
          while (true) {
              // read can take an additional numeric parameter to specify a timeout, in milliseconds; returning null indicates an error, timeout, or that the socket has been closed
              var buf = client.read()
              if (!buf) {
                  break
              }
              Log(buf)
          }
          client.close()
      }
  }
  

  
      python
      
      
  def main():
      client = Dial("tls://www.baidu.com:443")
      if client:
          client.write("GET / HTTP/1.1\nConnection: Closed\n\n")
          while True:
              buf = client.read()
              if not buf:
                  break
              Log(buf)
          client.close()
  

  
      rust
      
      
  fn main() {
      // Dial supports the tcp://, udp://, tls://, and unix:// protocols, and you can use Dial::new(addr, timeout) to specify the timeout in seconds
      let mut client = Dial("tls://www.baidu.com:443");
      if client.Valid() {
          // The second numeric parameter of write is used to specify a timeout, and it returns the number of bytes successfully sent
          client.write("GET / HTTP/1.1\nConnection: Closed\n\n", 0);
          loop {
              // The numeric parameter of read is used to specify a timeout, in milliseconds; returning an empty string indicates an error, timeout, or that the socket has been closed
              let buf = client.read(0);
              if buf == "" {
                  break;
              }
              Log!(buf);
          }
          client.close();
      }
  }
  

  
      c++
      
      
  void main() {
      auto client = Dial("tls://www.baidu.com:443");
      if(client.Valid) {
          client.write("GET / HTTP/1.1\nConnection: Closed\n\n");
          while(true) {
              auto buf = client.read();
              if(buf == "") {
                  break;
              }
              Log(buf);
          }
          client.close();
      }
  }
  

• Access Binance's WebSocket market data interface:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      LogStatus("Connecting...")
      // Access Binance's WebSocket interface
      var client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr")
      if (!client) {
          Log("Connection failed, exiting")
          return
      }
  
      while (true) {
          // read only returns data received after read is called
          var buf = client.read()
          if (!buf) {
              break
          }
          var table = {
              type: 'table',
              title: 'Market Chart',
              cols: ['Symbol', 'High', 'Low', 'Bid', 'Ask', 'Last Price', 'Volume', 'Update Time'],
              rows: []
          }
          var obj = JSON.parse(buf)
          _.each(obj, function(ticker) {
              table.rows.push([ticker.s, ticker.h, ticker.l, ticker.b, ticker.a, ticker.c, ticker.q, _D(ticker.E)])
          })
          LogStatus('`' + JSON.stringify(table) + '`')
      }
      client.close()
  }
  

  
      python
      
      
  import json
  def main():
      LogStatus("Connecting...")
      client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr")
      if not client:
          Log("Connection failed, exiting")
          return
  
      while True:
          buf = client.read()
          if not buf:
              break
          table = {
              "type" : "table",
              "title" : "Market Chart",
              "cols" : ["Symbol", "High", "Low", "Bid", "Ask", "Last Price", "Volume", "Update Time"],
              "rows" : []
          }
          obj = json.loads(buf)
          for i in range(len(obj)):
              table["rows"].append([obj[i]["s"], obj[i]["h"], obj[i]["l"], obj[i]["b"], obj[i]["a"], obj[i]["c"], obj[i]["q"], _D(int(obj[i]["E"]))])
          LogStatus('`' + json.dumps(table) + '`')
      client.close()
  

  
      rust
      
      
  fn main() {
      LogStatus!("Connecting...");
      // Access Binance's WebSocket interface
      let mut client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr");
      if !client.Valid() {
          Log!("Connection failed, exiting");
          return;
      }
  
      loop {
          // read only returns data received after read is called
          let buf = client.read(0);
          if buf == "" {
              break;
          }
          let obj = JSONParse(&buf).unwrap();
          // The Rust SDK has no JSON serialization; here we use string concatenation to build the JSON text for the status bar table
          let mut rows = String::new();
          if let Some(arr) = obj.as_array() {
              for ticker in arr {
                  if !rows.is_empty() {
                      rows += ",";
                  }
                  rows += &format!(r#"["{}","{}","{}","{}","{}","{}","{}","{}"]"#,
                      ticker["s"].as_str().unwrap_or(""), ticker["h"].as_str().unwrap_or(""),
                      ticker["l"].as_str().unwrap_or(""), ticker["b"].as_str().unwrap_or(""),
                      ticker["a"].as_str().unwrap_or(""), ticker["c"].as_str().unwrap_or(""),
                      ticker["q"].as_str().unwrap_or(""), _D(ticker["E"].as_i64().unwrap_or(0)));
              }
          }
          let table = format!(r#"{{"type":"table","title":"Market Chart","cols":["Symbol","High","Low","Bid","Ask","Last Price","Volume","Update Time"],"rows":[{}]}}"#, rows);
          LogStatus!(format!("`{}`", table));
      }
      client.close();
  }
  

  
      c++
      
      
  void main() {
      LogStatus("Connecting...");
      auto client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr");
      if(!client.Valid) {
          Log("Connection failed, exiting");
          return;
      }
  
      while(true) {
          auto buf = client.read();
          if(buf == "") {
              break;
          }
          json table = R"({
              "type" : "table",
              "title" : "Market Chart",
              "cols" : ["Symbol", "High", "Low", "Bid", "Ask", "Last Price", "Volume", "Update Time"],
              "rows" : []
          })"_json;
          json obj = json::parse(buf);
          for(auto& ele : obj.items()) {
              table["rows"].push_back({ele.value()["s"], ele.value()["h"], ele.value()["l"], ele.value()["b"], ele.value()["a"], ele.value()["c"],
                  ele.value()["q"], _D(ele.value()["E"])});
          }
          LogStatus("`" + table.dump() + "`");
      }
      client.close();
  }
  

• Access Binance's WebSocket interface and set the wss request headers.

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      let options = {"headers": {"X-MBX-APIKEY": "your access key"}}
      let random = `fmz${UnixNano()}`
      let ts = new Date().getTime()
      let secretKey = "your secret key"
      let topic = "com_announcement_en"
      let payload = `random=${random}&topic=${topic}&recvWindow=30000&timestamp=${ts}`
      let signature = Encode("sha256", "string", "hex", payload, "string", secretKey)
      let query = `?${payload}&signature=${signature}`
  
      Log("query:", query)
      let conn = Dial(`wss://api.binance.com/sapi/wss${query}`, options)
  
      for (var i = 0 ; i < 10 ; i++) {
          let ret = conn.read()
          Log(ret)
      }
  }
  

  
      python
      
      
  import time
  
  def main():
      options = {"headers": {"X-MBX-APIKEY": "your access key"}}
      random = "fmz" + str(UnixNano())
      ts = int(time.time() * 1000)
      secretKey = "your secret key"
      topic = "com_announcement_en"
      payload = f"random={random}&topic={topic}&recvWindow=30000&timestamp={ts}"
      signature = Encode("sha256", "string", "hex", payload, "string", secretKey)
      query = f"?{payload}&signature={signature}"
  
      Log("query:", query)
      conn = Dial(f"wss://api.binance.com/sapi/wss{query}", options)
  
      for i in range(10):
          ret = conn.read()
          Log(ret)
  

  
      rust
      
      
  fn main() {
      // In Rust, use Dial::with_options() and pass options as a JSON string to set the request headers
      let options = r#"{"headers": {"X-MBX-APIKEY": "your access key"}}"#;
      let random = format!("fmz{}", UnixNano());
      let ts = Unix() * 1000;
      let secretKey = "your secret key";
      let topic = "com_announcement_en";
      let payload = format!("random={}&topic={}&recvWindow=30000&timestamp={}", random, topic, ts);
      let signature = Encode("sha256", "string", "hex", &payload, "string", secretKey);
      let query = format!("?{}&signature={}", payload, signature);
  
      Log!("query:", query);
      let mut conn = Dial::with_options(&format!("wss://api.binance.com/sapi/wss{}", query), options);
  
      for _i in 0..10 {
          let ret = conn.read(0);
          Log!(ret);
      }
  }
  

  
      c++
      
      
  // Not supported yet

• Access OKX's WebSocket market data interface:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  var ws = null
  function main(){
      var param = {
          "op": "subscribe",
          "args": [{
              "channel": "tickers",
              "instId": "BTC-USDT"
          }]
      }
      // When calling the Dial function, specify reconnect=true to enable reconnection mode, and specify payload as the message to be sent upon reconnection. When the WebSocket connection is disconnected, it will automatically reconnect and automatically send this message
      ws = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload="+ JSON.stringify(param))
      if(ws){
          var pingCyc = 1000 * 20
          var lastPingTime = new Date().getTime()
          while(true){
              var nowTime = new Date().getTime()
              var ret = ws.read()
              Log("ret:", ret)
              if(nowTime - lastPingTime > pingCyc){
                  var retPing = ws.write("ping")
                  lastPingTime = nowTime
                  Log("Sending: ping", "#FF0000")
              }
              LogStatus("Current time:", _D())
              Sleep(1000)
          }
      }
  }
  
  function onexit() {
      ws.close()
      Log("Exiting")
  }
  

  
      python
      
      
  import json
  import time
  
  ws = None
  def main():
      global ws
      param = {
          "op": "subscribe",
          "args": [{
              "channel": "tickers",
              "instId": "BTC-USDT"
          }]
      }
      ws = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload=" + json.dumps(param))
      if ws:
          pingCyc = 1000 * 20
          lastPingTime = time.time() * 1000
          while True:
              nowTime = time.time() * 1000
              ret = ws.read()
              Log("ret:", ret)
              if nowTime - lastPingTime > pingCyc:
                  retPing = ws.write("ping")
                  lastPingTime = nowTime
                  Log("Sending: ping", "#FF0000")
              LogStatus("Current time:", _D())
              Sleep(1000)
  
  def onexit():
      ws.close()
      Log("Exiting")
  

  
      rust
      
      
  fn main() {
      let param = r#"{"op":"subscribe","args":[{"channel":"tickers","instId":"BTC-USDT"}]}"#;
      // When calling the Dial function, specify reconnect=true to enable reconnection mode, and specify payload as the message to be sent upon reconnection. When the WebSocket connection is disconnected, it will automatically reconnect and automatically send this message
      let mut ws = Dial(&format!("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload={}", param));
      if ws.Valid() {
          let pingCyc = 1000 * 20;
          let mut lastPingTime = Unix() * 1000;
          loop {
              let nowTime = Unix() * 1000;
              let ret = ws.read(0);
              Log!("ret:", ret);
              if nowTime - lastPingTime > pingCyc {
                  let retPing = ws.write("ping", 0);
                  lastPingTime = nowTime;
                  Log!("Sending: ping", "#FF0000");
              }
              LogStatus!("Current time:", _D(None));
              Sleep(1000);
          }
      }
      // In Rust, the connection object is automatically closed when it goes out of scope; you can also explicitly call ws.close()
  }
  

  
      c++
      
      
  auto objWS = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true");
  
  void main() {
      json param = R"({
          "op": "subscribe",
          "args": [{
              "channel": "tickers",
              "instId": "BTC-USDT"
          }]
      })"_json;
  
      objWS.write(param.dump());
      if(objWS.Valid) {
          uint64_t pingCyc = 1000 * 20;
          uint64_t lastPingTime = Unix() * 1000;
          while(true) {
              uint64_t nowTime = Unix() * 1000;
              auto ret = objWS.read();
              Log("ret:", ret);
              if(nowTime - lastPingTime > pingCyc) {
                  auto retPing = objWS.write("ping");
                  lastPingTime = nowTime;
                  Log("Sending: ping", "#FF0000");
              }
              LogStatus("Current time:", _D());
              Sleep(1000);
          }
      }
  }
  
  void onexit() {
      objWS.close();
      Log("Exiting");
  }
  

• Access the Huobi exchange's WebSocket market data interface:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  var ws = null
  
  function main(){
      var param = {"sub": "market.btcusdt.detail", "id": "id1"}
      ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload="+ JSON.stringify(param))
      if(ws){
          while(1){
              var ret = ws.read()
              Log("ret:", ret)
              // Respond to the heartbeat packet
              try {
                  var jsonRet = JSON.parse(ret)
                  if(typeof(jsonRet.ping) == "number") {
                      var strPong = JSON.stringify({"pong" : jsonRet.ping})
                      ws.write(strPong)
                      Log("Responding to ping, sending pong:", strPong, "#FF0000")
                  }
              } catch(e) {
                  Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
              }
  
              LogStatus("Current time:", _D())
              Sleep(1000)
          }
      }
  }
  
  function onexit() {
      ws.close()
      Log("Executing ws.close()")
  }
  

  
      python
      
      
  import json
  ws = None
  
  def main():
      global ws
      param = {"sub" : "market.btcusdt.detail", "id" : "id1"}
      ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload=" + json.dumps(param))
      if ws:
          while True:
              ret = ws.read()
              Log("ret:", ret)
              # Respond to the heartbeat packet
              try:
                  jsonRet = json.loads(ret)
                  if "ping" in jsonRet and type(jsonRet["ping"]) == int:
                      strPong = json.dumps({"pong" : jsonRet["ping"]})
                      ws.write(strPong)
                      Log("Responding to ping, sending pong:", strPong, "#FF0000")
              except Exception as e:
                  Log("e:", e)
  
              LogStatus("Current time:", _D())
              Sleep(1000)
  
  def onexit():
      ws.close()
      Log("Executing ws.close()")
  

  
      rust
      
      
  fn main() {
      let param = r#"{"sub":"market.btcusdt.detail","id":"id1"}"#;
      let mut ws = Dial(&format!("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload={}", param));
      if ws.Valid() {
          loop {
              let ret = ws.read(0);
              Log!("ret:", ret);
              // Respond to the heartbeat packet; in Rust use JSONParse() to parse, which returns None on parse failure
              if let Some(jsonRet) = JSONParse(&ret) {
                  if jsonRet["ping"].is_number() {
                      let strPong = format!(r#"{{"pong":{}}}"#, jsonRet["ping"].as_i64().unwrap_or(0));
                      ws.write(&strPong, 0);
                      Log!("Responding to ping, sending pong:", strPong, "#FF0000");
                  }
              }
  
              LogStatus!("Current time:", _D(None));
              Sleep(1000);
          }
      }
      // In Rust the connection object is automatically closed when it leaves scope; you can also explicitly call ws.close()
  }
  

  
      c++
      
      
  using namespace std;
  
  void main() {
      json param = R"({"sub" : "market.btcusdt.detail", "id" : "id1"})"_json;
      auto ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload=" + param.dump());
      if(ws.Valid) {
          while(true) {
              auto ret = ws.read();
              Log("ret:", ret);
              // Respond to the heartbeat packet
              try
              {
                  auto jsonRet = json::parse(ret);
                  if(jsonRet["ping"].is_number()) {
                      json pong = R"({"pong" : 0})"_json;
                      pong["pong"] = jsonRet["ping"];
                      auto strPong = pong.dump();
                      ws.write(strPong);
                      Log("Responding to ping, sending pong:", strPong, "#FF0000");
                  }
              } catch(exception &e)
              {
                  Log("e:", e.what());
              }
  
              LogStatus("Current time:", _D());
              Sleep(1000);
          }
      }
  }
  
  void onexit() {
      // ws.close();
      Log("Executing ws.close()")
  }
  

• Access OKX's WebSocket authentication interface:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function getLogin(pAccessKey, pSecretKey, pPassphrase) {
      // Signature function, used to generate the login request
      var ts = (new Date().getTime() / 1000).toString()
      var login = {
          "op": "login",
          "args":[{
              "apiKey"    : pAccessKey,
              "passphrase" : pPassphrase,
              "timestamp" : ts,
              "sign" : exchange.Encode("sha256", "string", "base64", ts + "GET" + "/users/self/verify", "string", pSecretKey)
          }]
      }
      return login
  }
  
  var client_private = null
  function main() {
      // Since the read function has a timeout set, timeout errors need to be filtered, otherwise redundant error output will be produced
      SetErrorFilter("timeout")
  
      // Subscription information for the positions channel
      var posSubscribe = {
          "op": "subscribe",
          "args": [{
              "channel": "positions",
              "instType": "ANY"
          }]
      }
  
      var accessKey = "xxx"
      var secretKey = "xxx"
      var passphrase = "xxx"
  
      client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
      client_private.write(JSON.stringify(getLogin(accessKey, secretKey, passphrase)))
      Sleep(3000)  // You cannot subscribe to private channels immediately after login; you need to wait for the server response
      client_private.write(JSON.stringify(posSubscribe))
      if (client_private) {
          var lastPingTS = new Date().getTime()
          while (true) {
              var buf = client_private.read(-1)
              if (buf) {
                  Log(buf)
              }
  
              // Reconnect after detecting a disconnection
              if (buf == "" && client_private.write(JSON.stringify(posSubscribe)) == 0) {
                  Log("Detected disconnection, closing connection, reconnecting")
                  client_private.close()
                  client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
                  client_private.write(JSON.stringify(getLogin(accessKey, secretKey, passphrase)))
                  Sleep(3000)
                  client_private.write(JSON.stringify(posSubscribe))
              }
  
              // Send heartbeat packet
              var nowPingTS = new Date().getTime()
              if (nowPingTS - lastPingTS > 10 * 1000) {
                  client_private.write("ping")
                  lastPingTS = nowPingTS
              }
          }
      }
  }
  
  function onexit() {
      var ret = client_private.close()
      Log("Connection closed!", ret)
  }
  

  
      python
      
      
  import json
  import time
  
  def getLogin(pAccessKey, pSecretKey, pPassphrase):
      ts = str(time.time())
      login = {
          "op": "login",
          "args":[{
              "apiKey"    : pAccessKey,
              "passphrase" : pPassphrase,
              "timestamp" : ts,
              "sign" : exchange.Encode("sha256", "string", "base64", ts + "GET" + "/users/self/verify", "string", pSecretKey)
          }]
      }
      return login
  
  client_private = None
  def main():
      global client_private
      SetErrorFilter("timeout")
  
      posSubscribe = {
          "op": "subscribe",
          "args": [{
              "channel": "positions",
              "instType": "ANY"
          }]
      }
  
      accessKey = "xxx"
      secretKey = "xxx"
      passphrase = "xxx"
  
      client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
      client_private.write(json.dumps(getLogin(accessKey, secretKey, passphrase)))
      Sleep(3000)
      client_private.write(json.dumps(posSubscribe))
      if client_private:
          lastPingTS = time.time() * 1000
          while True:
              buf = client_private.read(-1)
              if buf:
                  Log(buf)
  
              if buf == "" and client_private.write(json.dumps(posSubscribe)) == 0:
                  Log("Detected disconnection, closing connection, reconnecting")
                  ret = client_private.close()
                  client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
                  client_private.write(json.dumps(getLogin(accessKey, secretKey, passphrase)))
                  Sleep(3000)
                  client_private.write(json.dumps(posSubscribe))
  
              nowPingTS = time.time() * 1000
              if nowPingTS - lastPingTS > 10 * 1000:
                  client_private.write("ping")
                  lastPingTS = nowPingTS
  
  def onexit():
      ret = client_private.close()
      Log("Connection closed!", ret)
  

  
      rust
      
      
  fn getLogin(pAccessKey: &str, pSecretKey: &str, pPassphrase: &str) -> String {
      // Signature function, used to generate the login request. There is no exchange.Encode member function in Rust, so the global Encode function is used to compute the signature
      let ts = format!("{}", Unix());
      let sign = Encode("sha256", "string", "base64", &format!("{}GET/users/self/verify", ts), "string", pSecretKey);
      format!(r#"{{"op":"login","args":[{{"apiKey":"{}","passphrase":"{}","timestamp":"{}","sign":"{}"}}]}}"#, pAccessKey, pPassphrase, ts, sign)
  }
  
  fn main() {
      // Since the read function has a timeout set, timeout errors need to be filtered, otherwise redundant error output will be produced
      SetErrorFilter("timeout");
  
      // Subscription information for the positions channel
      let posSubscribe = r#"{"op":"subscribe","args":[{"channel":"positions","instType":"ANY"}]}"#;
  
      let accessKey = "xxx";
      let secretKey = "xxx";
      let passphrase = "xxx";
  
      let mut client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
      client_private.write(&getLogin(accessKey, secretKey, passphrase), 0);
      Sleep(3000);  // You cannot subscribe to private channels immediately after login; you need to wait for the server response
      client_private.write(posSubscribe, 0);
      if client_private.Valid() {
          let mut lastPingTS = Unix() * 1000;
          loop {
              let buf = client_private.read(-1);
              if buf != "" {
                  Log!(buf);
              }
  
              // Reconnect after detecting a disconnection
              if buf == "" && client_private.write(posSubscribe, 0) == 0 {
                  Log!("Detected disconnection, closing connection, reconnecting");
                  client_private.close();
                  client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
                  client_private.write(&getLogin(accessKey, secretKey, passphrase), 0);
                  Sleep(3000);
                  client_private.write(posSubscribe, 0);
              }
  
              // Send heartbeat packet
              let nowPingTS = Unix() * 1000;
              if nowPingTS - lastPingTS > 10 * 1000 {
                  client_private.write("ping", 0);
                  lastPingTS = nowPingTS;
              }
          }
      }
  }
  

  
      c++
      
      
  auto client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
  
  json getLogin(string pAccessKey, string pSecretKey, string
  pPassphrase) {
      auto ts = std::to_string(Unix());
      json login = R"({
          "op": "login",
          "args": [{
              "apiKey": "",
              "passphrase": "",
              "timestamp": "",
              "sign": ""
          }]
      })"_json;
      login["args"][0]["apiKey"] = pAccessKey;
      login["args"][0]["passphrase"] = pPassphrase;
      login["args"][0]["timestamp"] = ts;
      login["args"][0]["sign"] = exchange.Encode("sha256", "string", "base64", ts + "GET" + "/users/self/verify", "string", pSecretKey);
      return login;
  }
  
  void main() {
      SetErrorFilter("timeout");
      json posSubscribe = R"({
          "op": "subscribe",
          "args": [{
              "channel": "positions",
              "instType": "ANY"
          }]
      })"_json;
  
      auto accessKey = "xxx";
      auto secretKey = "xxx";
      auto passphrase = "xxx";
  
      client_private.write(getLogin(accessKey, secretKey, passphrase).dump());
      Sleep(3000);
      client_private.write(posSubscribe.dump());
  
      if (client_private.Valid) {
          uint64_t lastPingTS = Unix() * 1000;
  
          while (true) {
              auto buf = client_private.read(-1);
              if (buf != "") {
                  Log(buf);
              }
              if (buf == "") {
                  if (client_private.write(posSubscribe.dump()) == 0) {
                      Log("Detected disconnection, closing connection, reconnecting");
                      client_private.close();
                      client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
                      client_private.write(getLogin(accessKey, secretKey, passphrase).dump());
                      Sleep(3000);
                      client_private.write(posSubscribe.dump());
                  }
              }
  
              uint64_t nowPingTS = Unix() * 1000;
              if (nowPingTS - lastPingTS > 10 * 1000) {
                  client_private.write("ping");
                  lastPingTS = nowPingTS;
              }
          }
      }
  }
  
  void onexit() {
      client_private.close();
      Log("Exiting");
  }
  

• Access CoinEx's WebSocket authentication interface:

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  var conn = null
  function main() {
      var accessKey = "your accessKey"
  
      var ts = new Date().getTime()
      var signature = exchange.Encode("sha256", "string", "hex", String(ts), "string", "{{secretkey}}")
      Log("signature:", signature)
  
      var payload = {
          "id": 1,
          "method": "server.sign",
          "params": {
              "access_id": accessKey,
              "signed_str": signature,
              "timestamp": ts,
          }
      }
      Log(`JSON.stringify(payload):`, JSON.stringify(payload))
  
      conn = Dial("wss://socket.coinex.com/v2/futures|compress=gzip&mode=recv&payload=" + JSON.stringify(payload))
      if (!conn) {
          throw "stop"
      }
      Log("Dial ... ", conn.read())
  
      // Subscribe to position push
      conn.write(JSON.stringify({
          "method": "position.subscribe",
          "params": {"market_list": ["BTCUSDT"]},
          "id": 1
      }))
  
      while (true) {
          var msg = conn.read()
          if (msg) {
              Log("msg:", msg)
          }
      }
  }
  
  function onexit() {
      conn.close()
  }
  

  
      python
      
      
  // Omitted

  
      rust
      
      
  fn main() {
      let accessKey = "your accessKey";
  
      let ts = Unix() * 1000;
      // Rust does not have the exchange.Encode member function and cannot use the {{secretkey}} template substitution, so use the global Encode function to pass the secret key directly to compute the signature
      let signature = Encode("sha256", "string", "hex", &format!("{}", ts), "string", "your secretKey");
      Log!("signature:", signature);
  
      // The Rust SDK does not have JSON serialization, so use string concatenation to construct the payload's JSON text
      let payload = format!(r#"{{"id":1,"method":"server.sign","params":{{"access_id":"{}","signed_str":"{}","timestamp":{}}}}}"#, accessKey, signature, ts);
      Log!("payload:", payload);
  
      let mut conn = Dial(&format!("wss://socket.coinex.com/v2/futures|compress=gzip&mode=recv&payload={}", payload));
      if !conn.Valid() {
          Panic!("stop");
      }
      Log!("Dial ... ", conn.read(0));
  
      // Subscribe to position push
      conn.write(r#"{"method":"position.subscribe","params":{"market_list":["BTCUSDT"]},"id":1}"#, 0);
  
      loop {
          let msg = conn.read(0);
          if msg != "" {
              Log!("msg:", msg);
          }
      }
  }
  

  
      c++
      
      
  // Omitted

• The following example demonstrates how to access the Websocket interface of the MEXC exchange, subscribe to the public.aggre.deals.v3.api.pb channel, and use protobuf.js to decode the binary data:

  • javascript
  • python
  • cpp

  
      javascript
      
      
  let strPushDataV3ApiWrapper = `syntax = "proto3";
  
  
  
  option java_package = "com.mxc.push.common.protobuf";
  option optimize_for = SPEED;
  option java_multiple_files = true;
  option java_outer_classname = "PushDataV3ApiWrapperProto";
  
  message PublicAggreDealsV3Api {
  
    repeated PublicAggreDealsV3ApiItem deals  = 1;
    string eventType = 2;
  }
  
  message PublicAggreDealsV3ApiItem {
    string price = 1;
    string quantity = 2;
    int32 tradeType = 3;
    int64 time = 4;
  }
  
  message PushDataV3ApiWrapper {
    string channel = 1;
    oneof body {
      PublicAggreDealsV3Api publicAggreDeals = 314;
    }
  
    optional string symbol = 3;
    optional string symbolId = 4;
    optional int64 createTime = 5;
    optional int64 sendTime = 6;
  }`
  
  let code = HttpQuery("https://cdnjs.cloudflare.com/ajax/libs/protobufjs/7.5.3/protobuf.js")
  let exports = {}
  let module = { exports }
  new Function("module", "exports", code)(module, exports)
  let protobuf = module.exports
  
  function main() {
      const PushDataV3ApiWrapper = protobuf.parse(strPushDataV3ApiWrapper).root.lookupType("PushDataV3ApiWrapper")
  
      var payload = {
          "method": "SUBSCRIPTION",
          "params": [
              "[email protected]@100ms@BTCUSDT"
          ]
      }
  
      // proxy=socks5://x.x.x.x:xxxx
      var conn = Dial("wss://wbs-api.mexc.com/ws|payload=" + JSON.stringify(payload))
  
      var data = null
      while (true) {
          var ret = conn.read()
          if (ret) {
              const uint8arrayData = new Uint8Array(ret)
              const message = PushDataV3ApiWrapper.decode(uint8arrayData)
  
              data = PushDataV3ApiWrapper.toObject(message, {
                longs: String,
                enums: String,
                bytes: String,
                defaults: true,
                arrays: true,
                objects: true
              })
              Log("data:", data)
          }
          LogStatus(_D(), data)
      }
  }
  

  
      python
      
      
  # You can use the corresponding libraries in Python to implement encoding and decoding.

  
      c++
      
      
  // Omitted

• The connection object returned when the Dial function connects to a database has 2 unique methods:

  - exec(sqlString): Used to execute SQL statements, with usage similar to the DBExec() function.

  - fd(): This function returns a handle (for example, a handle variable named handle), used for reconnecting in other threads. Even if the connection object created by Dial has already been closed via the close() function, you can still pass this handle into the Dial() function (for example, Dial(handle)) to reuse the connection.

  The following is an example of using the Dial function to connect to a sqlite3 database.

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  var client = null
  function main() {
      // client = Dial("sqlite3://:memory:")   // Use an in-memory database
      client = Dial("sqlite3://test1.db")      // Open/connect to the database file in the docker's directory
  
      // Record the handle
      var sqlite3Handle = client.fd()
      Log("sqlite3Handle:", sqlite3Handle)
  
      // Query the tables in the database
      var ret = client.exec("SELECT name FROM sqlite_master WHERE type='table'")
      Log(ret)
  }
  
  function onexit() {
      Log("Executing client.close()")
      client.close()
  }
  

  
      python
      
      
  // Not supported

  
      rust
      
      
  fn main() {
      // let mut client = Dial("sqlite3://:memory:");   // Use an in-memory database
      let mut client = Dial("sqlite3://test1.db");      // Open/connect to the database file in the docker's directory
  
      // Rust's connection object does not support the fd() method
  
      // Query the tables in the database
      let ret = client.exec("SELECT name FROM sqlite_master WHERE type='table'");
      Log!(format!("{:?}", ret));
  
      Log!("Executing client.close()");
      client.close();
  }
  

  
      c++
      
      
  // Not supported

Returns

Arguments

Remarks

address parameter details: after the standard address wss://ws.okx.com:8443/ws/v5/public, use the | symbol as a separator. If the parameter string contains the | character, use || as the separator instead. The portion after the separator specifies the functional parameter settings, with individual parameters joined by the & character.

For example, to set both an ss5 proxy and compression parameters at the same time, you can write:

Dial("wss://ws.okx.com:8443/ws/v5/public|proxy=socks5://xxx:9999&compress=gzip_raw&mode=recv")

The Dial() function is only supported in live trading.

When using the Dial function to connect to a database, you can refer to the Go language driver project corresponding to each database for how to write the connection string.

Note that when the payload content set in the address parameter contains the character = or other special characters, it may affect how the Dial function parses the address parameter. See the example below.

Example of calling the backPack exchange websocket private interface:

            javascript
            
            
var client = null

function main() {
    // The base64-encoded public key of the key pair, i.e., the access key configured on FMZ
    var base64ApiKey = "xxx"

    var ts = String(new Date().getTime())
    var data = "instruction=subscribe&timestamp=" + ts + "&window=5000"

    // Since signEd25519 ultimately returns a base64 encoding, it may contain the character "="
    var signature = signEd25519(data)

    // After being JSON-encoded, payload may contain the character "="
    payload = {
        "method": "SUBSCRIBE",
        "params": ["account.orderUpdate"],
        "signature": [base64ApiKey, signature, ts, "5000"]
    }

    client = Dial("wss://ws.backpack.exchange")
    client.write(JSON.stringify(payload))
    if (!client) {
        Log("Connection failed, exiting")
        return
    }

    while (true) {
        var buf = client.read()
        Log(buf)
    }
}

function onexit() {
    client.close()
}

function signEd25519(data) {
    return exchange.Encode("ed25519.seed", "raw", "base64", data, "base64", "{{secretkey}}")
}

Using the following calling approach in the code works properly:

            javascript
            
            
client = Dial("wss://ws.backpack.exchange")
client.write(JSON.stringify(payload))

If it is written directly into the payload (in the address), it will not work properly, for example:

            javascript
            
            
client = Dial("wss://ws.backpack.exchange|payload=" +
JSON.stringify(payload))

Currently, only the JavaScript language supports using the mqtt, nats, amqp, and kafka communication protocols in the Dial function. The following uses JavaScript strategy code as an example to demonstrate how to use the four protocols mqtt, nats, amqp, and kafka:

            javascript
            
            
// You need to first configure and deploy the proxy servers for each protocol
// For ease of demonstration, both subscribing to (read operation) and publishing to (write operation) the topic test_topic are performed within this current strategy

var arrConn = []
var arrName = []

function main() {
    LogReset(1)
    conn_nats = Dial("nats://[email protected]:4222?topic=test_topic")
    conn_mqtt = Dial("mqtt://127.0.0.1:1883?topic=test_topic")
    conn_amqp = Dial("amqp://q:[email protected]:5672/?queue=test_Queue")
    conn_kafka = Dial("kafka://localhost:9092/test_topic")
    arrConn = [conn_nats, conn_amqp, conn_mqtt, conn_kafka]
    arrName = ["nats", "amqp", "mqtt", "kafka"]

    while (true) {
        for (var i in arrConn) {
            var conn = arrConn[i]
            var name = arrName[i]

            // Write data
            conn.write(name + ", time: " + _D() + ", test msg.")

            // Read data
            var readMsg = conn.read(1000)
            Log(name + " readMsg: ", readMsg, "#FF0000")
        }

        Sleep(1000)
    }
}

function onexit() {
    for (var i in arrConn) {
        arrConn[i].close()
        Log("Closing", arrName[i], "connection")
    }
}

For a detailed introduction, please refer to the documentation: Exploring FMZ: Practices of Communication Protocols Between Live Trading Strategies