क्रिप्टोक्यूरेंसी वायदा मार्टिंगेल-प्रकार की रणनीति डिजाइन

क्रिप्टोक्यूरेंसी वायदा मार्टिंगेल-प्रकार की रणनीति डिजाइन

हाल ही में, एफएमजेड आधिकारिक समूह में चर्चा की गई कई मार्टिंगेल-प्रकार की रणनीतियाँ हैं, और हमारे मंच पर क्रिप्टोक्यूरेंसी अनुबंधों की कई मार्टिंगेल रणनीतियाँ नहीं हैं। इसलिए, मैंने एक सरल क्रिप्टोक्यूरेंसी वायदा मार्टिंगेल-प्रकार की रणनीति डिजाइन करने का अवसर लिया। इसे मार्टिंगेल-प्रकार की रणनीति क्यों कहा जाता है? क्योंकि मार्टिंगेल रणनीति का संभावित जोखिम वास्तव में छोटा नहीं है, इसलिए मार्टिंगेल रणनीति के अनुसार डिजाइन करना आवश्यक नहीं है। हालांकि, इस प्रकार की रणनीतियों में अभी भी बहुत सारे जोखिम हैं, और मार्टिंगेल-प्रकार की रणनीति की पैरामीटर सेटिंग्स जोखिमों से निकटता से संबंधित हैं, और जोखिमों को नजरअंदाज नहीं किया जाना चाहिए।

इस लेख में, हम मुख्य रूप से समझाते हैं और मार्टिंगेल प्रकार की रणनीतियों के डिजाइन से सीखते हैं। रणनीति विचार पहले से ही बहुत स्पष्ट है, इसलिए हम, एफएमजेड उपयोगकर्ताओं के रूप में, रणनीति डिजाइन के बारे में अधिक विचार कर सकते हैं।

कुल इक्विटी प्राप्त करें

कुल इक्विटी का उपयोग अक्सर क्रिप्टोक्यूरेंसी वायदा रणनीति डिजाइन करते समय किया जाता है, क्योंकि हम लाभ की गणना करना चाहते हैं, खासकर जब हमें फ्लोटिंग लाभ की गणना करने की आवश्यकता होती है। चूंकि होल्डिंग पदों में मार्जिन होता है, इसलिए लंबित आदेश भी करते हैं। उस समय, एपीआई इंटरफ़ेसexchange.GetAccount()एफएमजेड प्लेटफॉर्म की उपलब्ध परिसंपत्तियों और लंबित आदेश जमे हुए परिसंपत्तियों को प्राप्त करने के लिए कहा जाता है। वास्तव में, अधिकांश क्रिप्टोक्यूरेंसी वायदा प्लेटफॉर्म कुल इक्विटी का डेटा प्रदान करते हैं, लेकिन यह संपत्ति एफएमजेड पर समान रूप से पैक नहीं की गई है।

इसलिए, हम अलग से विभिन्न प्लेटफार्मों के अनुसार डेटा प्राप्त करने के लिए कार्यों को डिजाइन करते हैंः

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

..totalEquityकोड में कुल इक्विटी हम की जरूरत है. तो हम एक समारोह के रूप में कॉल प्रविष्टि लिखते हैं, और मंच के नाम के अनुसार संबंधित समारोह कॉल.

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

कई सहायक कार्यों का डिजाइन

मुख्य कार्य और मुख्य तर्क को डिजाइन करने से पहले, हमें तैयारी के लिए कुछ सहायक कार्यों को भी डिजाइन करने की आवश्यकता है।

• सभी लंबित आदेश रद्द करें

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

  यह फ़ंक्शन उन लोगों के लिए परिचित माना जाता है जो अक्सर एफएमजेड रणनीति वर्ग पर रणनीति उदाहरण कोड पढ़ते हैं, और कई रणनीतियों ने इसी तरह के डिजाइन का उपयोग किया है। फ़ंक्शन वर्तमान लंबित आदेश सूची प्राप्त करना है, और फिर आदेशों को एक-एक करके रद्द करना है।

• वायदा ऑर्डर देने का परिचालन

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

  फ्यूचर्स ट्रेडिंग के लिए चार दिशाएं हैंः ओपन लॉन्ग पोजीशन (openLong), ओपन शॉर्ट पोजीशन (openShort), क्लोज लॉन्ग पोजीशन (coverLong), और क्लोज शॉर्ट पोजीशन (coverShort). इसलिए, हमने इन ऑपरेशनों के अनुरूप चार ऑर्डर फ़ंक्शन डिज़ाइन किए हैं। यदि आप केवल ऑर्डर देने पर विचार करते हैं, तो कई आवश्यक कारक हैंः दिशा, ऑर्डर मूल्य और ऑर्डर राशि।

  हमने एक फ़ंक्शन भी बनाया जिसका नाम था:tradeऑपरेशन को संभालने के लिए जबdirection (distance), order price (price)औरorder amount (amount)निर्दिष्ट हैं।

  खुली लंबी स्थिति (openLong), खुली छोटी स्थिति (openShort), बंद लंबी स्थिति (coverLong), और बंद छोटी स्थिति (coverShort) के फ़ंक्शन कॉल अंततःtradeकार्य, अर्थात, निर्दिष्ट दिशा, मूल्य और राशि के अनुसार, वायदा प्लेटफार्मों में ऑर्डर दें।

मुख्य कार्य

रणनीति का विचार बहुत सरल है; वर्तमान मूल्य को आधार रेखा के रूप में लें, और आधार रेखा के ऊपर और नीचे एक निश्चित दूरी से बेचने के आदेश (लघु) और खरीदने के आदेश (लंबे) रखने के लिए। यदि एक पक्ष के आदेश निष्पादित किए जाते हैं, तो शेष सभी आदेशों को रद्द करें, और फिर स्थिति मूल्य के अनुसार एक निश्चित दूरी पर नए बंद आदेश रखे जाएंगे, और खरीद आदेश अद्यतन वर्तमान मूल्य पर रखे जाएंगे, लेकिन खरीद आदेश आदेश राशि को दोगुना नहीं करेंगे।

• प्रारंभिक कार्य हम आदेश लंबित करना चाहते हैं के लिए, हम आदेश आईडी रिकॉर्ड करने के लिए दो चर की जरूरत है.

  var buyOrderId = null
  var sellOrderId = null
  

  फिर, OKEX_V5 सिमुलेटेड बॉट का उपयोग करने का विकल्प रणनीति इंटरफ़ेस मापदंडों में डिज़ाइन किया गया है, इसलिए कोड में कुछ प्रसंस्करण करने की आवश्यकता हैः

  var exName = exchange.GetName()    
  // switch to OKEX V5 simulated bot 
  if (isSimulate && exName == "Futures_OKCoin") {
      exchange.IO("simulate", true)
  }
  

  सभी जानकारी को रीसेट करने का विकल्प भी रणनीति मापदंडों में डिज़ाइन किया गया है, इसलिए कोड में कुछ प्रसंस्करण करने की आवश्यकता हैः

  if (isReset) {
      _G(null)
      LogReset(1)
      LogProfitReset()
      LogVacuum()
      Log("Reset all data", "#FF0000")
  }
  

  हम केवल शाश्वत अनुबंध चलाते हैं, तो यहाँ हम इसे एक अनंत लूप में लिखते हैं, और हम इसे केवल शाश्वत अनुबंध पर सेट करते हैं।

  exchange.SetContractType("swap")
  

  इसके अलावा, हमें ऑर्डर की कीमत और ऑर्डर राशि की सटीकता की समस्याओं पर विचार करने की आवश्यकता है। यदि सटीकता ठीक से सेट नहीं की जाती है, तो यह रणनीति गणना प्रक्रिया के दौरान खो जाएगी। यदि डेटा में बड़ी संख्या में दशमलव अंक हैं, तो प्लेटफ़ॉर्म इंटरफ़ेस द्वारा ऑर्डर को अस्वीकार करना आसान है।

  exchange.SetPrecision(pricePrecision, amountPrecision)
  Log("set percision", pricePrecision, amountPrecision)
  

  डिजाइन में सरल डेटा रिकवरी समारोह

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

  यदि आप रणनीति चलाने पर खाते की प्रारंभिक कुल इक्विटी निर्दिष्ट करना चाहते हैं, तो आप पैरामीटर सेट कर सकते हैंtotalEq. यदि यह पैरामीटर -1 पर सेट है, तो रणनीति संग्रहीत कुल इक्विटी डेटा पढ़ेगी। यदि कोई संग्रहीत कुल इक्विटी डेटा नहीं है, तो वर्तमान में पढ़ी गई कुल इक्विटी रणनीति चल रही प्रगति में प्रारंभिक कुल इक्विटी के रूप में उपयोग की जाती है। बाद में, यदि कुल इक्विटी बढ़ जाती है, तो इसका मतलब है कि इसने लाभ अर्जित किया है; यदि कुल इक्विटी घटती है, तो इसका मतलब है कि नुकसान है। यदि कुल इक्विटी डेटा पढ़ा जाता है, तो डेटा का उपयोग चलना जारी रखने के लिए करें।

• मुख्य तर्क प्रारंभिक कार्य पूरा होने के बाद, हम अंततः रणनीति के मुख्य तर्क भाग में पहुंचे। स्पष्टीकरण की सुविधा के लिए, मैंने टिप्पणी सीधे कोड में लिखी।

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

इसके बाद पूरे तर्क और डिजाइन को पूरी तरह से समझाया गया है।

बैकटेस्ट

रणनीति को 19 मई, 2021 को बाजार उद्धरणों को पार करने दें।

जैसा कि हम देख सकते हैं, मार्टिंगेल रणनीति के समान रणनीति में अभी भी कुछ जोखिम हैं।

बॉट परीक्षण चलाने के लिए OKEX V5 सिम्युलेटेड बॉट का उपयोग कर सकते हैं

रणनीतिक पता:https://www.fmz.com/strategy/294957

रणनीति मुख्य रूप से अध्ययन के लिए प्रयोग किया जाता है, तो एक असली बॉट में रणनीति संचालित नहीं करते!