Penjelasan terperinci tentang konfigurasi pertukaran strategi perdagangan kuantitatif mata wang digital

Apabila anda baru mula mereka bentuk strategi perdagangan kuantitatif mata wang digital, anda sering mempunyai pelbagai keperluan strategi Tidak kira bahasa atau platform yang anda gunakan, anda akan menghadapi keperluan reka bentuk strategi untuk pelbagai situasi. Sebagai contoh, kadangkala pelbagai jenis perlu diputar, kadangkala berbilang platform perlu dilindung nilai, dan kadangkala varieti yang berbeza perlu didagangkan serentak, dsb. Mari kongsikan beberapa pengalaman reka bentuk apabila melaksanakan keperluan strategik. Platform pembelajaran masih menggunakan Platform Dagangan Kuantitatif Inventor (https://www.fmz.com), dan pasaran yang dipilih ialah pasaran mata wang digital.

• ### Reka bentuk strategi “berbilang mata wang”.

Jenis permintaan ini selalunya memerlukan penulisan strategi aliran pelbagai variasi, strategi grid pelbagai variasi, dsb., yang memerlukan pelaksanaan berulang logik strategi menggunakan pasangan dagangan yang berbeza. Biasanya direka seperti ini:

  function Process (symbol) {
      exchange.IO("currency", symbol)
      var ticker = _C(exchange.GetTicker)
      Log("已经切换交易对，按照策略逻辑处理交易对 ：", symbol, "行情：", ticker)
      // ...
      // ..
      // .
  }  

  function main(){
      var symbols = ["BTC_USDT", "LTC_USDT", "ETH_USDT"]
      while (true) {
          for (var i = 0 ; i < symbols.length; i++) {
              Process(symbols[i])
              Sleep(500)
          }
      }
  }

Kami mengkonfigurasi robot:

Seperti yang anda lihat, ini memungkinkan untuk mengkonfigurasi objek pertukaran pada robot, menukar pasangan dagangan, mendapatkan keadaan pasaran pasangan dagangan yang berbeza, menjalankan keadaan pasaran berbilang pelbagai dan melaksanakan di bawah logik strategi. Dapat dilihat bahawa tiga pasangan dagangan yang kami takrifkan: BTC_USDT, LTC_USDT, ETH_USDT, diulang secara bergilir-gilir dalam gelung untuk mendapatkan maklumat pasaran Selepas mendapat maklumat pasaran, kami boleh mengesan maklumat pasaran secara khusus dan mencetuskan logik dagangan yang direka oleh strategi.

Sesetengah pelajar mungkin berkata: “Saya tidak suka menukar pasangan dagangan. Rasanya agak menyusahkan dan reka bentuk strategi tidak jelas.” Memang ada kaedah reka bentuk lain, yang merupakan kaedah lain yang kami perkenalkan di bawah.

• ### Konfigurasikan berbilang objek pertukaran untuk robot dengan akaun pertukaran yang sama

Dapatkan data pasaran untuk pasangan dagangan yang berbeza melalui berbilang objek pertukaran dan laksanakannya dalam logik strategi berulang. Sebagai contoh, konfigurasikan robot seperti ini: konfigurasikan tiga objek pertukaran untuk robot, dan tetapkan pasangan dagangan kepada BTC_USDT, LTC_USDT dan ETH_USDT masing-masing.

Objek pertukaran bernama “OKEX Spot V3 Test” berada di pusat kawalan, halaman konfigurasi pertukaran: Sudah dikonfigurasikan.

Ubah suai kod kerana kali ini kami menambah berbilang objek pertukaran pada robot, iaitu objek pertukaran dengan pasangan dagangan BTC_USDT, LTC_USDT dan ETH_USDT.

  function Process (e) {
      var ticker = _C(e.GetTicker)
      Log("交易所", e.GetName(), "按照策略逻辑处理交易对 ：", e.GetCurrency(), "行情：", ticker)
      // ...
      // ..
      // .
  }  

  function main(){
      while (true) {
          for (var i = 0 ; i < exchanges.length; i++) {
              Process(exchanges[i])
              Sleep(500)
          }
      }
  }

Jalankan robot:

Contoh yang diterangkan di atas adalah mengenai menukar pasangan dagangan atau menambah objek pertukaran dengan berbilang pasangan dagangan berbeza ke akaun yang dikonfigurasikan. Semua dikonfigurasikan menggunakan hanya satu akaun pertukaran (menggunakan pertukaran yang dikonfigurasikan). Jadi bagaimana anda menggunakan berbilang akaun pertukaran dalam satu strategi?

• ### Strategi untuk menggunakan berbilang akaun pertukaran

Strategi tertentu termasuk, sebagai contoh, lindung nilai merentas pasaran merentas berbilang bursa, strategi berbilang akaun dalam satu bursa, dsb.

• Berbilang pertukaran dikonfigurasikan, tetapi ia adalah pertukaran yang berbeza. Sebagai contoh, saya mengkonfigurasi 2 pertukaran dalam halaman Pusat Kawalan->Exchange->Add Exchange. Saya boleh mengakses maklumat aset akaun yang dikonfigurasikan pada kedua-dua bursa ini dalam strategi.

  

  function main(){
      Log(exchanges[0].GetAccount())    // 打印第一个 交易所对象的账户资产信息，即火币期货 这个交易所的资产信息。
      Log(exchanges[1].GetAccount())    // ... 打印Bit-Z这个交易所的资产信息
  }
  

  Sudah tentu, saya juga boleh menambah konfigurasi pertukaran akaun kedua dan ketiga pada pertukaran.

• Konfigurasi pertukaran berbilang adalah pertukaran yang sama.

  Sebagai contoh, mari tambah satu lagi akaun Huobi Futures.

  Seperti yang anda lihat, dua akaun pertukaran “Huobi Futures” telah dikonfigurasikan.

  

  Apabila mencipta strategi, objek Huobi Futures Exchange muncul dalam pilihan “Ubah Suai Konfigurasi” robot untuk pemilihan.

  

  Sebagai contoh, anda boleh mempunyai dua akaun, satu menggunakan strategi grid jual-pertama-beli-kemudian (naik) dan satu lagi menggunakan strategi grid beli-dahulu-jual-kemudian (menurun).

  Melalui dua contoh di atas

  Berikut ialah perbezaan antara mengkonfigurasi berbilang objek pertukaran pada robot dan mengkonfigurasi berbilang objek pertukaran untuk robot dengan akaun pertukaran yang sama:

  Pada pandangan pertama, ini agak serupa dengan contoh “Mengkonfigurasi berbilang objek pertukaran untuk robot dengan akaun pertukaran yang sama” yang dijelaskan di atas, tetapi terdapat perbezaan. Perbezaannya ialah contoh di atas adalah konfigurasi pertukaran, iaitu:

  

  Apabila mengkonfigurasi objek pertukaran dalam robot, sentiasa gunakan: Konfigurasi ini.

  Cuma tetapan pasangan dagangan berbeza apabila menambah objek pertukaran. Jika anda memanggil fungsi GetAccount, anda akan sentiasa mengakses maklumat aset akaun yang sama.

  Walau bagaimanapun: Dua objek Huobi Futures Exchange dikonfigurasikan dengan cara ini, walaupun kedua-duanya adalah Huobi Futures, mewakili akaun pertukaran yang berbeza.

• Gunakan konfigurasi pertukaran dengan baik untuk menjadikan reka bentuk strategi niaga hadapan mata wang digital lebih mudah.

Kadangkala apabila melaksanakan strategi lindung nilai kontrak mata wang digital, untuk merebut peluang dagangan sekejap, banyak senario memerlukan pesanan serentak. Walau bagaimanapun, kerana kontrak adalah berbeza, anda perlu beralih kepada kontrak yang sepadan apabila mendapatkan maklumat pasaran dan membuat pesanan. Apabila menggunakan fungsi exchange.Go untuk melaksanakan fungsi pesanan secara serentak atau mendapatkan maklumat pasaran, ia tidak begitu pantas disebabkan isu penyegerakan. Dan reka bentuk pertukaran kontrak menjadikan logiknya kelihatan tidak begitu mudah. Jadi adakah cara yang lebih baik?

Sudah tentu ada caranya! Kita boleh menambah dua objek pertukaran pada robot mengikut penerangan di atas tentang “Mengkonfigurasi berbilang objek pertukaran untuk robot dengan akaun pertukaran yang sama”. Kemudian, masih menggunakan konfigurasi pertukaran ini, tambahkan objek pertukaran lain. Kotak gesaan akan muncul pada masa ini! Konfigurasi akaun pertukaran tidak boleh menambah objek pertukaran dengan mata wang dan pasangan dagangan yang sama.

Apa yang perlu saya lakukan dalam kes ini? Nampaknya tidak mungkin untuk membiarkan robot strategi menggunakan dua objek pertukaran dan mengikat objek pertukaran kepada satu kod akaun pertukaran? Masih ada jalan!

Kami pergi ke “Pusat Kawalan” -> “Pertukaran” dan menambah konfigurasi pertukaran niaga hadapan OKEX.

Selepas konfigurasi, klik Simpan.

### 「Serlahkan」Kini kami mempunyai dua konfigurasi pertukaran, tetapi maklumat konfigurasi API KEY yang sama digunakan.

Apakah faedah ini? Sudah tentu, apabila menulis strategi, reka bentuknya sangat mudah!

  function main(){
      exchanges[0].SetContractType("quarter")        // 设置第一个添加的交易所对象 当前的合约为季度合约
      exchanges[1].SetContractType("this_week")      // 设置第二个添加的交易所对象，当前的合约为当周合约

      while (true) {
          var beginTime = new Date().getTime()       // 记录这次获取行情时起始的时间戳。
          var rA = exchanges[0].Go("GetTicker")      // 创建并发 线程去获取 第一个交易所对象，也就是季度合约的行情数据。
          var rB = exchanges[1].Go("GetTicker")      // 创建并发 线程去获取 第二个交易所对象，也就是当周合约的行情数据。

          var tickerA = rA.wait()                    // 并发的两个线程各自执行自己的任务，这里等待获取数据，A 等待时，B任务也在执行。
          var tickerB = rB.wait()                    // 所以这里看似是顺序执行，实际在底层是并发的。只不过获取的时候是顺序先获取A，在获取B。
          var endTime = new Date().getTime()         // 记录并发获取两个合约行情结束时的时间戳。

          if (tickerA && tickerB) {                  // 如果获取的数据没有问题，执行以下逻辑。
              var diff = tickerA.Last - tickerB.Last // 计算差价
              $.PlotLine("diff", diff)               // 使用画线类库把差价画在图表上。
              if (diff > 500) {                      // 如果差价大于500， 对冲套利（当然设置500 的差价是比较大的，很少见。）
                  // 对冲
                  rA = exchanges[0].Go("Sell", tickerA.Buy, 1)     // 并发线程创建 季度合约下卖单
                  rB = exchanges[1].Go("Buy", tickerB.Sell, 1)     // 并发线程创建 当周合约下买单

                  var idA = rA.wait()           // 等待 返回下单结果，返回的是订单ID
                  var idB = rB.wait()           // ...
              }

              // ...
          }

          LogStatus(_D(), "并发获取两个合约行情耗时：", endTime - beginTime, "毫秒。")    // 显示在状态栏上时间，以便知道程序在执行。
          Sleep(500)
      }
  }

Adakah strategi reka bentuk ini terasa lebih mudah dan idea lebih jelas?

Operasi cakera sebenar:

Ia boleh dilihat bahawa ia hanya mengambil masa kira-kira 50 milisaat untuk mendapatkan maklumat pasaran dua kontrak secara serentak setiap kali.