Penjelasan rinci tentang konfigurasi pertukaran strategi perdagangan kuantitatif mata uang digital

Saat Anda baru mulai merancang strategi perdagangan kuantitatif mata uang digital, Anda sering kali memiliki berbagai persyaratan strategi. Apa pun bahasa atau platform yang Anda gunakan, Anda akan menghadapi persyaratan desain strategi untuk berbagai situasi. Misalnya, terkadang beberapa varietas perlu dirotasi, terkadang beberapa platform perlu dilindung nilai, dan terkadang varietas yang berbeda perlu diperdagangkan secara bersamaan, dsb. Mari berbagi beberapa pengalaman desain saat mengimplementasikan persyaratan strategis. Platform pembelajaran masih menggunakan Platform Perdagangan Kuantitatif Inventor (https://www.fmz.com), dan pasar yang dipilih adalah pasar mata uang digital.

• ### Desain strategi “Multi-mata uang”

Jenis permintaan ini sering kali memerlukan penulisan strategi tren multi-variasi, strategi grid multi-variasi, dsb., yang memerlukan eksekusi berulang dari logika strategi menggunakan pasangan perdagangan yang berbeda. Biasanya dirancang 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 bisa Anda lihat, ini memungkinkan untuk mengonfigurasi objek pertukaran pada robot, mengganti pasangan perdagangan, mendapatkan kondisi pasar dari pasangan perdagangan yang berbeda, melakukan berbagai kondisi pasar, dan mengeksekusi di bawah logika strategi. Dapat dilihat bahwa tiga pasangan perdagangan yang kami definisikan: BTC_USDT, LTC_USDT, ETH_USDT, diulang secara bergantian dalam loop untuk mendapatkan informasi pasar. Setelah mendapatkan informasi pasar, kami dapat secara khusus mendeteksi informasi pasar dan memicu logika perdagangan yang dirancang dengan strategi.

Beberapa siswa mungkin berkata: “Saya tidak suka berganti pasangan perdagangan. Rasanya agak merepotkan dan desain strateginya tidak jelas.” Memang ada metode desain lainnya, yang merupakan metode lain yang kami perkenalkan di bawah ini.

• ### Konfigurasikan beberapa objek pertukaran untuk robot dengan akun pertukaran yang sama

Dapatkan data pasar untuk berbagai pasangan perdagangan melalui beberapa objek bursa dan jalankan dalam logika strategi berulang. Misalnya, konfigurasikan robot seperti ini: konfigurasikan tiga objek pertukaran untuk robot, dan tetapkan pasangan perdagangan masing-masing ke BTC_USDT, LTC_USDT, dan ETH_USDT.

Objek pertukaran bernama “OKEX Spot V3 Test” ada di pusat kendali, halaman konfigurasi pertukaran: Sudah dikonfigurasi.

Ubah kode karena kali ini kami menambahkan beberapa objek pertukaran ke robot, yaitu objek pertukaran dengan pasangan perdagangan 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 robotnya:

Contoh yang dijelaskan di atas adalah tentang mengalihkan pasangan perdagangan atau menambahkan objek pertukaran dengan beberapa pasangan perdagangan berbeda ke akun yang dikonfigurasikan. Semuanya dikonfigurasikan hanya menggunakan satu akun bursa (menggunakan bursa yang dikonfigurasikan). Jadi bagaimana Anda menggunakan beberapa akun bursa dalam satu strategi?

• ### Strategi untuk menggunakan beberapa akun pertukaran

Strategi tertentu mencakup, misalnya, lindung nilai lintas pasar di beberapa bursa, strategi multi-akun dalam satu bursa, dll.

• Beberapa bursa dikonfigurasikan, tetapi bursa-bursa tersebut berbeda. Misalnya, saya mengonfigurasi 2 bursa di Pusat Kontrol->Bursa->halaman Tambah Bursa. Saya dapat mengakses informasi aset akun yang dikonfigurasi di kedua bursa ini dalam strategi tersebut.

  

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

  Tentu saja, saya juga dapat menambahkan konfigurasi pertukaran akun kedua dan ketiga ke bursa.

• Beberapa konfigurasi bursa adalah bursa yang sama.

  Misalnya, mari tambahkan akun Huobi Futures lainnya.

  Seperti yang Anda lihat, dua akun bursa “Huobi Futures” telah dikonfigurasi.

  

  Saat membuat strategi, objek Huobi Futures Exchange muncul di opsi “Ubah Konfigurasi” robot untuk dipilih.

  

  Misalnya, Anda dapat memiliki dua akun, satu menggunakan strategi jual-dulu-beli-nanti (ke atas), dan yang lainnya menggunakan strategi beli-dulu-jual-nanti (ke bawah).

  Melalui dua contoh di atas

  Berikut ini perbedaan antara mengonfigurasi beberapa objek pertukaran pada robot dan mengonfigurasi beberapa objek pertukaran untuk robot dengan akun pertukaran yang sama:

  Sekilas, ini agak mirip dengan contoh “Mengonfigurasi beberapa objek pertukaran untuk robot dengan akun pertukaran yang sama” yang dijelaskan di atas, tetapi ada perbedaan. Perbedaannya adalah contoh di atas adalah konfigurasi pertukaran, yaitu:

  

  Saat mengonfigurasi objek pertukaran di robot, selalu gunakan: Konfigurasi ini.

  Hanya saja pengaturan pasangan perdagangannya berbeda saat menambahkan objek pertukaran. Jika Anda memanggil fungsi GetAccount, Anda akan selalu mengakses informasi aset dari akun yang sama.

  Namun: Kedua objek Huobi Futures Exchange yang dikonfigurasikan dengan cara ini, meskipun keduanya adalah Huobi Futures, mewakili akun bursa yang berbeda.

• Manfaatkan konfigurasi pertukaran dengan baik untuk mempermudah perancangan strategi berjangka mata uang digital.

Terkadang ketika menerapkan strategi lindung nilai kontrak mata uang digital, untuk memanfaatkan peluang perdagangan yang cepat berlalu, banyak skenario memerlukan pesanan serentak. Namun, karena kontraknya berbeda, Anda perlu beralih ke kontrak yang sesuai saat memperoleh informasi pasar dan melakukan pemesanan. Saat menggunakan fungsi exchange.Go untuk menjalankan fungsi order atau memperoleh informasi pasar secara bersamaan, prosesnya tidak terlalu cepat karena masalah sinkronisasi. Dan desain kontrak peralihan membuat logikanya tampak tidak begitu sederhana. Jadi apakah ada cara yang lebih baik?

Tentu saja ada caranya! Kita dapat menambahkan dua objek pertukaran ke robot sesuai dengan uraian di atas “Mengonfigurasi beberapa objek pertukaran untuk robot dengan akun pertukaran yang sama”. Kemudian, masih menggunakan konfigurasi pertukaran ini, tambahkan objek pertukaran lainnya. Kotak perintah akan muncul pada saat ini! Konfigurasi akun pertukaran tidak dapat menambahkan objek pertukaran dengan mata uang dan pasangan perdagangan yang sama.

Apa yang harus saya lakukan dalam kasus ini? Tampaknya tidak mungkin membiarkan robot strategi menggunakan dua objek pertukaran dan mengikat objek pertukaran ke satu kode akun pertukaran? Masih ada jalan!

Kita masuk ke “Pusat Kontrol” -> “Bursa” dan tambahkan konfigurasi bursa berjangka OKEX.

Setelah konfigurasi, klik Simpan.

### 「Sorotan」Sekarang kita memiliki dua konfigurasi pertukaran, tetapi informasi konfigurasi KUNCI API yang sama digunakan.

Apa manfaatnya? Tentu saja, ketika menulis strategi, desainnya sangat sederhana!

  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)
      }
  }

Apakah strategi desain ini terasa jauh lebih sederhana dan idenya jauh lebih jelas?

Operasi disk nyata:

Dapat dilihat bahwa hanya dibutuhkan sekitar 50 milidetik untuk memperoleh informasi pasar dari dua kontrak secara bersamaan setiap waktu.