Sumber daya yang dimuat... Pemuatan...

Desain Strategi Jenis Martingale Futures Cryptocurrency

Penulis:Ninabadass, Dibuat: 2022-04-12 17:50:07, Diperbarui: 2022-04-12 18:06:07

Desain Strategi Jenis Martingale Futures Cryptocurrency

Baru-baru ini, ada banyak strategi tipe Martingale yang dibahas di grup resmi FMZ, dan tidak banyak strategi Martingale kontrak cryptocurrency di platform kami. Oleh karena itu, saya mengambil kesempatan ini untuk merancang strategi tipe Martingale berjangka cryptocurrency sederhana. Mengapa disebut strategi tipe Martingale? Karena potensi risiko strategi Martingale memang tidak kecil, tidak perlu merancang sesuai dengan strategi Martingale. Namun, jenis strategi ini masih memiliki banyak risiko, dan pengaturan parameter strategi tipe Martingale terkait erat dengan risiko, dan risiko tidak boleh diabaikan.

Dalam artikel ini, kami terutama menjelaskan dan belajar dari desain strategi jenis Martingale. ide strategi itu sendiri sudah sangat jelas, sehingga kita, sebagai pengguna FMZ, dapat mempertimbangkan lebih banyak tentang desain strategi.

Dapatkan Ekuitas Total

Total ekuitas sering digunakan ketika merancang strategi berjangka cryptocurrency, karena kita ingin menghitung keuntungan, terutama ketika kita perlu menghitung keuntungan mengambang.exchange.GetAccount()Pada dasarnya, sebagian besar platform berjangka cryptocurrency menyediakan data dari total ekuitas, tetapi properti ini tidak dikemas secara seragam di FMZ.

Oleh karena itu, kami secara terpisah merancang fungsi untuk mendapatkan data sesuai dengan platform yang berbeda:

// 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 sesuai sesuai dengan 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"
    }
}

Desain Beberapa Fungsi Bantuan

Sebelum merancang fungsi utama dan logika utama, kita juga perlu merancang beberapa fungsi bantu untuk persiapan.

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 diyakini akrab bagi mereka yang sering membaca kode contoh strategi pada kotak strategi FMZ, dan banyak strategi telah menggunakan desain yang sama.

Operasi penempatan pesanan berjangka
```
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)
}
```
Ada empat arah untuk perdagangan berjangka: posisi terbuka panjang (openLong), posisi terbuka pendek (openShort), posisi dekat panjang (coverLong), dan posisi dekat pendek (coverShort). Oleh karena itu, kami merancang empat fungsi pesanan untuk sesuai dengan operasi ini. Jika Anda hanya mempertimbangkan penempatan pesanan, maka ada beberapa faktor yang diperlukan: arah, harga pesanan, dan jumlah pesanan.

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

Panggilan fungsi posisi panjang terbuka (openLong), posisi pendek terbuka (openShort), posisi panjang dekat (coverLong), dan posisi pendek dekat (coverShort) akhirnya diselesaikan olehtradefungsi, yaitu, sesuai dengan arah yang ditentukan, harga dan jumlah, menempatkan pesanan di platform berjangka.

Fungsi Utama

Ide strategi sangat sederhana; ambil harga saat ini sebagai garis dasar, dan dari jarak tertentu di atas dan di bawah garis dasar untuk menempatkan pesanan jual (pendek) dan pesanan beli (panjang).

Pekerjaan awal Untuk kita ingin menunggu pesanan, kita perlu dua variabel untuk merekam ID pesanan.
```
var buyOrderId = null
var sellOrderId = null
```
Kemudian, opsi untuk menggunakan bot simulasi OKEX_V5 dirancang dalam parameter antarmuka strategi, sehingga beberapa pemrosesan perlu dilakukan dalam kode:
```
var exName = exchange.GetName()    
// switch to OKEX V5 simulated bot 
if (isSimulate && exName == "Futures_OKCoin") {
    exchange.IO("simulate", true)
}
```
Pilihan untuk mengatur ulang semua informasi juga dirancang dalam parameter strategi, sehingga beberapa pemrosesan perlu dilakukan dalam kode:
```
if (isReset) {
    _G(null)
    LogReset(1)
    LogProfitReset()
    LogVacuum()
    Log("Reset all data", "#FF0000")
}
```
Kita hanya menjalankan kontrak abadi, jadi di sini kita menulisnya dalam loop tak terbatas, dan kita hanya mengaturnya untuk kontrak abadi.
```
exchange.SetContractType("swap")
```
Selain itu, kita perlu mempertimbangkan masalah presisi harga pesanan dan jumlah pesanan. Jika presisi tidak ditetapkan dengan benar, itu akan hilang selama proses perhitungan strategi. Jika data memiliki sejumlah besar desimal, mudah menyebabkan pesanan ditolak oleh antarmuka platform.
```
exchange.SetPrecision(pricePrecision, amountPrecision)
Log("set percision", pricePrecision, amountPrecision)
```
Fungsi pemulihan data sederhana dalam desain
```
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 ekuitas total awal akun saat menjalankan strategi, Anda dapat mengatur parametertotalEqJika parameter ini ditetapkan pada -1, strategi akan membaca data ekuitas total yang tersimpan. Jika tidak ada data ekuitas total yang tersimpan, total ekuitas yang saat ini dibaca digunakan sebagai total ekuitas awal dalam strategi yang sedang berjalan. Kemudian, jika total ekuitas meningkat, itu berarti bahwa ia telah memperoleh keuntungan; jika total ekuitas menurun, itu berarti bahwa ada kerugian. Jika data ekuitas total dibaca, gunakan data untuk terus berjalan.

Logika Utama Setelah pekerjaan awal selesai, kami akhirnya datang ke bagian logika utama dari strategi. untuk kenyamanan penjelasan, saya menulis komentar langsung ke dalam kode.

  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 logika dan desain sepenuhnya dijelaskan kemudian.

Backtest

Biarkan strategi melintasi kutipan pasar pada 19 Mei 2021.

Seperti yang kita lihat, strategi yang mirip dengan strategi Martingale masih memiliki risiko tertentu.

Tes bot dapat menggunakan OKEX V5 simulasi bot untuk menjalankan

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

Strategi ini terutama digunakan untuk studi, jadi jangan mengoperasikan strategi di bot nyata!

Lebih banyak

2019 FMZ - Semua hak dilindungi