Sumber dimuat naik... memuat...

Reka bentuk strategi jenis Martingale untuk niaga hadapan mata wang kripto

Penulis:Ninabadass, Dicipta: 2022-04-12 17:50:07, Dikemas kini: 2022-04-12 18:06:07

Reka bentuk strategi jenis Martingale untuk niaga hadapan mata wang kripto

Baru-baru ini, terdapat banyak strategi jenis Martingale yang dibincangkan dalam kumpulan rasmi FMZ, dan tidak banyak strategi Martingale kontrak mata wang kripto di platform kami. Oleh itu, saya mengambil peluang ini untuk merancang strategi jenis Martingale niaga hadapan mata wang kripto yang mudah. Mengapa ia dipanggil strategi jenis Martingale? Kerana risiko berpotensi strategi Martingale memang tidak kecil, tidak perlu merancang mengikut strategi Martingale. Walau bagaimanapun, jenis strategi ini masih mempunyai banyak risiko, dan tetapan parameter strategi jenis Martingale berkaitan erat dengan risiko, dan risiko tidak boleh diabaikan.

Dalam artikel ini, kita terutamanya menerangkan dan belajar dari reka bentuk strategi jenis Martingale. idea strategi itu sendiri sudah sangat jelas, jadi kita, sebagai pengguna FMZ, boleh mempertimbangkan lebih lanjut mengenai reka bentuk strategi.

Dapatkan Ekuiti Penuh

Jumlah ekuiti sering digunakan ketika merancang strategi niaga hadapan cryptocurrency, kerana kita ingin mengira keuntungan, terutamanya apabila kita perlu mengira keuntungan terapung.exchange.GetAccount()Pada masa yang sama, kebanyakan platform niaga hadapan cryptocurrency menyediakan data jumlah ekuiti, tetapi harta ini tidak dikemas secara seragam di FMZ.

Oleh itu, kami merancang secara berasingan fungsi untuk mendapatkan data mengikut platform yang berbeza:

// OKEX V5 obtains the total equity 
function getTotalEquity_OKEX_V5() {
    var totalEquity = null 
    var ret = exchange.IO("api", "GET", "/api/v5/account/balance", "ccy=USDT")
    if (ret) {
        try {
            totalEquity = parseFloat(ret.data[0].details[0].eq)
        } catch(e) {
            Log("Fail to obtain the total equity of the account!")
            return null
        }
    }
    return totalEquity
}

// Binance Ftures 
function getTotalEquity_Binance() {
    var totalEquity = null 
    var ret = exchange.GetAccount()
    if (ret) {
        try {
            totalEquity = parseFloat(ret.Info.totalWalletBalance)
        } catch(e) {
            Log("Fail to obtain the total equity!")
            return null
        }
    }
    return totalEquity
}

PeraturantotalEquityKemudian kita menulis fungsi sebagai entri panggilan, dan memanggil fungsi yang sepadan mengikut nama platform.

function getTotalEquity() {
    var exName = exchange.GetName()
    if (exName == "Futures_OKCoin") {
        return getTotalEquity_OKEX_V5()
    } else if (exName == "Futures_Binance") {
        return getTotalEquity_Binance()
    } else {
        throw "Do not support the platform"
    }
}

Reka bentuk beberapa fungsi pembantu

Sebelum mereka bentuk fungsi utama dan logik utama, kita juga perlu untuk mereka bentuk beberapa fungsi tambahan untuk persediaan.

Batalkan semua pesanan yang sedang menunggu
```
function cancelAll() {
    while (1) {
        var orders = _C(exchange.GetOrders)
        if (orders.length == 0) {
            break
        }
        for (var i = 0 ; i < orders.length ; i++) {
            exchange.CancelOrder(orders[i].Id, orders[i])
            Sleep(500)
        }
        Sleep(500)
    }
}
```
Fungsi ini dipercayai biasa bagi mereka yang sering membaca kod contoh strategi di kotak strategi FMZ, dan banyak strategi telah menggunakan reka bentuk yang sama. Fungsi ini adalah untuk mendapatkan senarai pesanan yang sedang menunggu, dan kemudian membatalkan pesanan satu demi satu.
Operasi meletakkan pesanan niaga hadapan
```
function trade(distance, price, amount) {
    var tradeFunc = null 
    if (distance == "buy") {
        tradeFunc = exchange.Buy
    } else if (distance == "sell") {
        tradeFunc = exchange.Sell
    } else if (distance == "closebuy") {
        tradeFunc = exchange.Sell
    } else {
        tradeFunc = exchange.Buy
    }
    exchange.SetDirection(distance)
    return tradeFunc(price, amount)
}

function openLong(price, amount) {
    return trade("buy", price, amount)
}

function openShort(price, amount) {
    return trade("sell", price, amount)
}

function coverLong(price, amount) {
    return trade("closebuy", price, amount)
}

function coverShort(price, amount) {
    return trade("closesell", price, amount)
}
```
Terdapat empat arah untuk perdagangan niaga hadapan: posisi panjang terbuka (openLong), kedudukan pendek terbuka (openShort), kedudukan panjang dekat (coverLong), dan kedudukan pendek dekat (coverShort). Oleh itu, kami merancang empat fungsi pesanan untuk sepadan dengan operasi ini. Jika anda hanya mempertimbangkan penempatan pesanan, maka terdapat beberapa faktor yang diperlukan: arah, harga pesanan, dan jumlah pesanan.

Kami juga merancang fungsi bernama:tradeuntuk mengendalikan operasi apabiladirection (distance), order price (price)danorder amount (amount)ditentukan.

Panggilan fungsi kedudukan panjang terbuka (openLong), kedudukan pendek terbuka (openShort), kedudukan panjang dekat (coverLong), dan kedudukan pendek dekat (coverShort) akhirnya diselesaikan olehtradefungsi, iaitu, mengikut arah yang ditentukan, harga dan jumlah, tempat pesanan di platform niaga hadapan.

Fungsi Utama

Idea strategi adalah sangat mudah; mengambil harga semasa sebagai garis asas, dan dari jarak tertentu di atas dan di bawah garis asas untuk meletakkan pesanan jual (pendek) dan pesanan beli (panjang).

Kerja awal Untuk kita mahu menunggu pesanan, kita memerlukan dua pembolehubah untuk merekod ID pesanan.
```
var buyOrderId = null
var sellOrderId = null
```
Kemudian, pilihan untuk menggunakan bot simulasi OKEX_V5 direka dalam parameter antara muka strategi, jadi beberapa pemprosesan perlu dilakukan dalam kod:
```
var exName = exchange.GetName()    
// switch to OKEX V5 simulated bot 
if (isSimulate && exName == "Futures_OKCoin") {
    exchange.IO("simulate", true)
}
```
Pilihan untuk menetapkan semula semua maklumat juga direka dalam parameter strategi, jadi beberapa pemprosesan perlu dilakukan dalam kod:
```
if (isReset) {
    _G(null)
    LogReset(1)
    LogProfitReset()
    LogVacuum()
    Log("Reset all data", "#FF0000")
}
```
Kita hanya menjalankan kontrak kekal, jadi di sini kita menulisnya dalam gelung tanpa akhir, dan kita hanya menetapkannya sebagai kontrak kekal.
```
exchange.SetContractType("swap")
```
Juga, kita perlu mempertimbangkan masalah ketepatan harga pesanan dan jumlah pesanan. Jika ketepatan tidak ditetapkan dengan betul, ia akan hilang semasa proses pengiraan strategi. Jika data mempunyai sebilangan besar angka perpuluhan, mudah menyebabkan pesanan ditolak oleh antara muka platform.
```
exchange.SetPrecision(pricePrecision, amountPrecision)
Log("set percision", pricePrecision, amountPrecision)
```
Fungsi pemulihan data yang mudah dalam reka bentuk
```
if (totalEq == -1 && !IsVirtual()) {
    var recoverTotalEq = _G("totalEq")
    if (!recoverTotalEq) {
        var currTotalEq = getTotalEquity()
        if (currTotalEq) {
            totalEq = currTotalEq
            _G("totalEq", currTotalEq)
        } else {
            throw "Fail to obtain the initial equity"
        }
    } else {
        totalEq = recoverTotalEq
    }
}
```
Jika anda ingin menentukan jumlah ekuiti awal akaun semasa menjalankan strategi, anda boleh menetapkan parametertotalEq. Jika parameter ini ditetapkan kepada -1, strategi akan membaca data ekuiti keseluruhan yang disimpan. Jika tidak ada data ekuiti keseluruhan yang disimpan, ekuiti keseluruhan yang sedang dibaca digunakan sebagai ekuiti keseluruhan awal dalam strategi yang sedang berjalan. Kemudian, jika ekuiti keseluruhan meningkat, ini bermakna ia telah memperoleh keuntungan; jika ekuiti keseluruhan menurun, ini bermakna terdapat kerugian. Jika data ekuiti keseluruhan dibaca, gunakan data untuk terus berjalan.

Logik Utama Selepas kerja awal dilakukan, kita akhirnya datang ke bahagian logik utama strategi. untuk kemudahan penjelasan, saya menulis komen terus dalam kod.

  while (1) {                                  // the main logic of the strategy is designed as an infinite loop
      var ticker = _C(exchange.GetTicker)      // read the current market information first, in which we mainly use the latest trading price
      var pos = _C(exchange.GetPosition)       // read the current position data 
      if (pos.length > 1) {                    // judge the position data; due to the strategy logic, it is unlikely to have long and short positions at the same time, so if there are long and short positions at the same time, an error will be thrown
          Log(pos)
          throw "concurrently with long and short positions"                  // raise an error, and stop the strategy 
      }
      // according to the status 
      if (pos.length == 0) {                    // according to the position status, make different operations; if pos.length == 0, it means currently no position
          // when there is no position yet, calculate the equity 
          if (!IsVirtual()) {
              var currTotalEq = getTotalEquity()
              if (currTotalEq) {
                  LogProfit(currTotalEq - totalEq, "Current total equity:", currTotalEq)
              }
          }

          buyOrderId = openLong(ticker.Last - targetProfit, amount)       // pend buy order of open long position 
          sellOrderId = openShort(ticker.Last + targetProfit, amount)     // pend sell order of open short position
      } else if (pos[0].Type == PD_LONG) {   // there are long positions; pending position and amount are 
          var n = 1
          var price = ticker.Last
          buyOrderId = openLong(price - targetProfit * n, amount)
          sellOrderId = coverLong(pos[0].Price + targetProfit, pos[0].Amount)
      } else if (pos[0].Type == PD_SHORT) {   // there are short positions; pending position and amount are different 
          var n = 1
          var price = ticker.Last
          buyOrderId = coverShort(pos[0].Price - targetProfit, pos[0].Amount)
          sellOrderId = openShort(price + targetProfit * n, amount)
      }

      if (!sellOrderId || !buyOrderId) {   // if opending orders of one side fails, cancel all pending orders and try again 
          cancelAll()
          buyOrderId = null 
          sellOrderId = null
          continue
      } 

      while (1) {  // finish pending the order, and start to monitor the order
          var isFindBuyId = false 
          var isFindSellId = false
          var orders = _C(exchange.GetOrders)
          for (var i = 0 ; i < orders.length ; i++) {
              if (buyOrderId == orders[i].Id) {
                  isFindBuyId = true 
              }
              if (sellOrderId == orders[i].Id) {
                  isFindSellId = true 
              }               
          }
          if (!isFindSellId && !isFindBuyId) {    // both buy order and sell order are detected to be executed 
              cancelAll()
              break
          } else if (!isFindBuyId) {   // a buy order execution is detected 
              Log("buy order executed")
              cancelAll()
              break
          } else if (!isFindSellId) {  // a sell order execution is detected 
              Log("sell order executed")
              cancelAll()
              break
          }
          LogStatus(_D())
          Sleep(3000)
      }
      Sleep(500)
  }

Seluruh logik dan reka bentuk dijelaskan sepenuhnya.

Ujian belakang

Biarkan strategi melintasi sebut harga pasaran pada 19 Mei 2021.

Seperti yang kita lihat, strategi yang serupa dengan strategi Martingale masih mempunyai risiko tertentu.

Bot ujian boleh menggunakan OKEX V5 simulasi bot untuk menjalankan

Alamat strategi:https://www.fmz.com/strategy/294957

Strategi ini digunakan terutamanya untuk kajian, jadi jangan mengoperasikan strategi dalam bot sebenar!

Lebih lanjut

2019 FMZ - Semua hak dilindungi