Strategi perdagangan kuantitatif mata uang digital

Strategi perdagangan kuantitatif mata uang digital

Ketika Anda mulai merancang strategi perdagangan kuantitatif mata uang digital, seringkali ada berbagai kebutuhan strategi yang berbeda, tidak peduli bahasa dan platform yang digunakan. Misalnya, terkadang diperlukan berbagai macam putaran, terkadang diperlukan banyak platform lindung nilai, terkadang diperlukan berbagai macam perdagangan bersamaan, dan sebagainya. Di bawah ini kita berbagi beberapa pengalaman desain ketika kebutuhan strategi terwujud. Platform pembelajaran masih menggunakan inventor untuk melakukan transaksi kuantitatif.https://www.fmz.com), pasar memilih pasar mata uang digital.

• Desain Strategi "Multicurrency"

  Situasi kebutuhan seperti ini lebih banyak karena perlu menulis strategi tren multi-varietas, strategi grid multi-varietas, dll. Biasanya desain 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 dapat dilihat, hal ini memungkinkan untuk mengkonfigurasi objek bursa pada robot, menukar pasangan perdagangan, mendapatkan pasar dari pasangan perdagangan yang berbeda, melakukan berbagai pasar, yang dilakukan di bawah logika strategi. Anda dapat melihat bahwa tiga pasangan perdagangan yang kami definisikan: BTC_USDT, LTC_USDT, ETH_USDT, secara berurutan mendapatkan pasar dalam siklus, setelah mendapatkan pasar, Anda dapat secara khusus untuk deteksi pasar, memicu logika perdagangan yang dirancang dengan baik.

  Beberapa teman-teman sekolah mungkin akan mengatakan: Saya tidak suka bertukar pasangan, saya merasa sedikit bermasalah, strategi yang dirancang tidak jelas. Namun, ada juga cara lain untuk mendesain, yaitu cara lain yang akan kami jelaskan di bawah ini.

• Robot dapat mengkonfigurasi beberapa objek pertukaran untuk akun yang sama

  Mengambil data pasar dari pasangan perdagangan yang berbeda melalui beberapa objek bursa, yang dilakukan dalam logika strategi iterasi. Misalnya, konfigurasi robot seperti ini: Konfigurasikan tiga objek pertukaran untuk robot, dengan pasangan transaksi masing-masing ditetapkan sebagai BTC_USDT, LTC_USDT, dan ETH_USDT.

  Nama objek bursa adalah "OKEX Live V3 Test", di Control Center, halaman konfigurasi bursa:"Sudah dikonfigurasi.

  Perbaiki kode, karena kali ini kami menambahkan beberapa objek pertukaran ke robot, yaitu pasangan perdagangan BTC_USDT, LTC_USDT, 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)
          }
      }
  }
  

  Robot yang berjalan:

  Contoh-contoh di atas, baik untuk menukar pasangan transaksi, atau menambahkan beberapa pasangan transaksi yang berbeda untuk sebuah akun konfigurasi. Semua hanya menggunakan konfigurasi akun bursa (menggunakan akun yang dikonfigurasi dengan baik). Jadi bagaimana menggunakan beberapa akun bursa dalam satu strategi?

• Strategi untuk menggunakan beberapa akun bursa

  Beberapa strategi, misalnya, multi-exchange cross-market hedging, multi-account strategi dalam satu bursa, dll.

  • Beberapa bursa dikonfigurasi, tetapi berbeda.Sebagai contoh, saya mengkonfigurasi 2 bursa di Control Center - > Exchange - > Add Exchange. Saya dapat mengakses informasi aset dari akun yang dikonfigurasi di kedua bursa di strategi ini.

    

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

    Tentu saja saya juga bisa menambahkan akun kedua atau ketiga ke sebuah bursa.

  • Di sini, Anda dapat melihat beberapa jenis bursa yang berbeda, yang merupakan bursa yang sama.

    Sebagai contoh, kita menambahkan satu akun token berjangka.

    Seperti yang Anda lihat, ini mengkonfigurasi dua akun bursa "token futures".

    

    Pada saat membuat kebijakan, sebuah objek bursa berjangka token muncul lagi untuk dipilih dalam opsi "Modifikasi Konfigurasi" bot.

    

    Sebagai contoh, Anda dapat membuat dua akun yang satu melakukan strategi jual-beli terlebih dahulu ("ke atas") dan yang satu melakukan strategi jual-beli terlebih dahulu ("ke bawah").

    Dengan menggunakan dua contoh di atas.

    Berikut ini adalah perbedaan antara mengkonfigurasi beberapa objek bursa pada robot dan "mengkonfigurasi beberapa objek bursa pada robot untuk akun bursa yang sama":

    Pada pandangan pertama, contoh ini mirip dengan contoh di atas, "Akun bursa yang sama dikonfigurasi untuk robot dengan beberapa objek bursa", tetapi ada perbedaan. Perbedaan dari contoh di atas adalah konfigurasi bursa, yaitu:

    

    Saat robot mengkonfigurasi objek bursa, selalu digunakan:Perangkat ini adalah sebuah perangkat lunak.

    Hanya saja ketika menambahkan objek bursa, transaksi akan berbeda dengan pengaturan. Jika Anda memanggil fungsi GetAccount, semua informasi aset dari akun yang sama akan selalu diakses.

    Namun:Dua token yang dikonfigurasi dengan cara ini adalah obyek bursa berjangka, meskipun keduanya adalah tokens berjangka, yang diwakili oleh akun bursa yang berbeda.

• Dengan menggunakan konfigurasi bursa, membuat strategi berjangka mata uang digital lebih mudah dirancang.

  Kadang-kadang dalam strategi untuk melakukan kontrak mata uang digital, banyak skenario yang membutuhkan order simultan untuk mengambil kesempatan perdagangan yang akan segera berlalu. Tetapi karena kontrak berbeda, perlu beralih ke kontrak yang sesuai saat mendapatkan pasar, operasi order simultan dilakukan. Ketika menggunakan fungsi exchange.Go, tidak terlalu cepat karena masalah sinkronisasi. Dan desain kontrak switching seperti itu juga membuat logika tampak tidak begitu sederhana. Apakah ada cara yang lebih baik?

  Tentu saja ada cara! Kita bisa menambahkan dua objek pertukaran ke robot seperti yang kita katakan di atas, "Akun bursa yang sama dikonfigurasi untuk robot dengan beberapa objek bursa".Kemudian, gunakan konfigurasi bursa ini untuk menambahkan objek bursa. Pada saat itu, kotak petunjuk akan muncul!Konfigurasi akun pertukaran tidak dapat menambahkan mata uang yang sama, pasangan transaksi, dan objek pertukaran.

  Bagaimana caranya? tampaknya tidak mungkin untuk membuat robot strategi menggunakan dua objek pertukaran dan memiliki kode akun yang terikat pada objek pertukaran? Ada cara untuk melakukannya!

  Kami menambahkan konfigurasi bursa berjangka OKEX di Control Center -> Exchange.

  

  Setelah mengkonfigurasi, klik Save.

  

  Dengan cara ini, kita memiliki dua konfigurasi pertukaran, tetapi menggunakan informasi konfigurasi API KEY yang sama.

  

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

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

  "Saya tidak tahu apakah strategi desain ini terasa lebih sederhana atau lebih jelas.

  Perangkat ini berjalan pada:

  Seperti yang Anda lihat, setiap kali Anda mendapatkan dua kontrak secara bersamaan, hanya membutuhkan waktu sekitar 50 millisecond.