डिजिटल मुद्राओं के लिए नकदी हेजिंग रणनीतियों का डिजाइन (1)

डिजिटल मुद्राओं के लिए नकदी हेजिंग रणनीतियों का डिजाइन (1)

रणनीति डिजाइन करने के लिए शुरुआती लोगों के लिए, हेजिंग रणनीति एक बहुत अच्छी अभ्यास रणनीति है। यह लेख एक सरल लेकिन व्यावहारिक डिजिटल मुद्रा नकदी हेजिंग रणनीति का कार्यान्वयन करता है, जिससे शुरुआती लोगों को कुछ डिजाइन अनुभव सीखने की उम्मीद है।

रणनीति की आवश्यकताओं के अनुसार कुछ फ़ंक्शन, रणनीति इंटरफ़ेस पैरामीटर डिजाइन करें

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

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

इन विचारों के आधार पर, रणनीति को कुछ मापदंडों को डिजाइन करने की आवश्यकता हैः

• हेजिंग की कीमतःhedgeDiffPrice, जब मूल्य इस मूल्य से अधिक हो जाता है, तो हेजिंग ऑपरेशन को ट्रिगर करता है।
• सबसे कम हेजिंगःminHedgeAmount, सबसे कम गिरने वाली इकाई (मुद्राओं की संख्या) ।
• अधिकतम हेजिंगःmaxHedgeAmount, एक बार में एक ही समय में सबसे कम इकाई राशि (मुद्राओं की संख्या) ।
• A कीमत सटीकताःpricePrecisionA, एक्सचेंज A में ऑर्डर की कीमत की सटीकता (छोटे अंक) ।
• A निम्न मात्रा में सटीकताःamountPrecisionA, A एक्सचेंज के लिए सबसे कम मात्रा सटीकता (छोटे अंक) ।
• B कीमत की सटीकताःpricePrecisionB, एक्सचेंज बी द्वारा ऑर्डर की गई कीमतों की सटीकता (छोटे अंक) ।
• B नीचे एकमुश्त सटीकताःamountPrecisionB, बी एक्सचेंज के नीचे की मात्रा की सटीकता (छोटे अंक) ।
• A एक्सचेंज का विनिमय दरःrateA, पहले जोड़े गए एक्सचेंज ऑब्जेक्ट का विनिमय दर रूपांतरण, डिफ़ॉल्ट रूप से 1 नहीं परिवर्तित किया गया है.
• एक्सचेंज बी का विनिमय दरःrateB, दूसरे जोड़े गए एक्सचेंज ऑब्जेक्ट के लिए विनिमय दर रूपांतरण, डिफ़ॉल्ट रूप से 1 नहीं परिवर्तित किया गया।

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

• अपडेटAccs

  function updateAccs(arrEx) {
      var ret = []
      for (var i = 0 ; i < arrEx.length ; i++) {
          var acc = arrEx[i].GetAccount()
          if (!acc) {
              return null
          }
          ret.push(acc)
      }
      return ret 
  }
  

यदि कोई ऑर्डर नहीं है, तो हमें समय पर रद्द करने की आवश्यकता है, इसलिए ऑर्डर को लटका नहीं रखा जा सकता है। यह ऑपरेशन संतुलन मॉड्यूल या हेजिंग लॉजिक में दोनों को संसाधित करने की आवश्यकता है, इसलिए एक ऑर्डर पूर्ण रद्द फ़ंक्शन डिजाइन करने की आवश्यकता है।

• रद्द करेंसभी

  function cancelAll() {
      _.each(exchanges, function(ex) {
          while (true) {
              var orders = _C(ex.GetOrders)
              if (orders.length == 0) {
                  break
              }
              for (var i = 0 ; i < orders.length ; i++) {
                  ex.CancelOrder(orders[i].Id, orders[i])
                  Sleep(500)
              }
          }
      })
  }
  

जब हम सिक्कों की संख्या को संतुलित करते हैं, तो हमें कुछ गहराई के डेटा में उन कीमतों का पता लगाने की आवश्यकता होती है जो एक निश्चित सिक्कों की संख्या तक बढ़ जाती हैं, इसलिए हमें इस तरह के एक फ़ंक्शन की आवश्यकता होती है।

• getDepthPrice

  function getDepthPrice(depth, side, amount) {
      var arr = depth[side]
      var sum = 0
      var price = null
      for (var i = 0 ; i < arr.length ; i++) {
          var ele = arr[i]
          sum += ele.Amount
          if (sum >= amount) {
              price = ele.Price
              break
          }
      }
      return price
  }
  

और फिर हमें एक विशिष्ट हेजिंग के लिए एक ऑर्डर ऑपरेशन को डिजाइन करने की आवश्यकता होती है, जिसे एक साथ ऑर्डर करने के लिए डिज़ाइन किया जाना चाहिएः

• हेज

  function hedge(buyEx, sellEx, price, amount) {
      var buyRoutine = buyEx.Go("Buy", price, amount)
      var sellRoutine = sellEx.Go("Sell", price, amount)
      Sleep(500)
      buyRoutine.wait()
      sellRoutine.wait()
  }
  

अंत में, हम संतुलन फ़ंक्शन के डिजाइन को पूरा करते हैं, और संतुलन फ़ंक्शन थोड़ा जटिल है।

• संतुलन बनाए रखना

  function keepBalance(initAccs, nowAccs, depths) {
      var initSumStocks = 0
      var nowSumStocks = 0 
      _.each(initAccs, function(acc) {
          initSumStocks += acc.Stocks + acc.FrozenStocks
      })
      _.each(nowAccs, function(acc) {
          nowSumStocks += acc.Stocks + acc.FrozenStocks
      })
    
      var diff = nowSumStocks - initSumStocks
      // 计算币差
      if (Math.abs(diff) > minHedgeAmount && initAccs.length == nowAccs.length && nowAccs.length == depths.length) {
          var index = -1
          var available = []
          var side = diff > 0 ? "Bids" : "Asks"
          for (var i = 0 ; i < nowAccs.length ; i++) {
              var price = getDepthPrice(depths[i], side, Math.abs(diff))
              if (side == "Bids" && nowAccs[i].Stocks > Math.abs(diff)) {
                  available.push(i)
              } else if (price && nowAccs[i].Balance / price > Math.abs(diff)) {
                  available.push(i)
              }
          }
          for (var i = 0 ; i < available.length ; i++) {
              if (index == -1) {
                  index = available[i]
              } else {
                  var priceIndex = getDepthPrice(depths[index], side, Math.abs(diff))
                  var priceI = getDepthPrice(depths[available[i]], side, Math.abs(diff))
                  if (side == "Bids" && priceIndex && priceI && priceI > priceIndex) {
                      index = available[i]
                  } else if (priceIndex && priceI && priceI < priceIndex) {
                      index = available[i]
                  }
              }
          }
          if (index == -1) {
              Log("无法平衡")            
          } else {
              // 平衡下单
              var price = getDepthPrice(depths[index], side, Math.abs(diff))
              if (price) {
                  var tradeFunc = side == "Bids" ? exchanges[index].Sell : exchanges[index].Buy
                  tradeFunc(price, Math.abs(diff))
              } else {
                  Log("价格无效", price)
              }
          }        
          return false
      } else if (!(initAccs.length == nowAccs.length && nowAccs.length == depths.length)) {
          Log("错误：", "initAccs.length:", initAccs.length, "nowAccs.length:", nowAccs.length, "depths.length:", depths.length)
          return true 
      } else {
          return true 
      }
  }
  

इन कार्यों को रणनीति की आवश्यकताओं के अनुसार डिज़ाइन किया गया है, नीचे नीति के मुख्य कार्यों को डिज़ाइन करना शुरू किया गया है।

रणनीतिक मुख्य फ़ंक्शन डिजाइन

FMZ पर रणनीति यह है किmainफ़ंक्शन को चलाया जाता है.mainफ़ंक्शन के आरंभ के भाग में हम कुछ रणनीतियों को आरंभ करने का काम करेंगे.

• एक्सचेंज का नाम चूंकि रणनीति में बहुत सारे ऑपरेशन एक्सचेंज ऑब्जेक्ट्स के लिए उपयोग किए जाते हैं, जैसे कि बाजार प्राप्त करना, ऑर्डर करना, आदि। इसलिए हर बार एक लंबे नाम का उपयोग करना मुश्किल हो सकता है, छोटी चाल एक सरल नाम का उपयोग करना है, उदाहरण के लिएः

  var exA = exchanges[0]
  var exB = exchanges[1]
  

  इस तरह, बाद में कोड लिखना आरामदायक है।

• विनिमय दर, सटीक डिजाइन

    // 精度，汇率设置
    if (rateA != 1) {
        // 设置汇率A
        exA.SetRate(rateA)
        Log("交易所A设置汇率：", rateA, "#FF0000")
    }
    if (rateB != 1) {
        // 设置汇率B
        exB.SetRate(rateB)
        Log("交易所B设置汇率：", rateB, "#FF0000")
    }
    exA.SetPrecision(pricePrecisionA, amountPrecisionA)
    exB.SetPrecision(pricePrecisionB, amountPrecisionB)
  

  यदि विनिमय दर पैरामीटरrateA、rateB1 के लिए सेट किया गया है ((डिफ़ॉल्ट रूप से 1) है, यानीrateA != 1याrateB != 1यह ट्रिगर नहीं करता है, इसलिए विनिमय दर रूपांतरण सेट नहीं करता है।

• सभी डेटा रीसेट करें

  

  कभी-कभी नीति को प्रारंभ करने पर सभी लॉग्स, रिक्त रिकॉर्ड डेटा को हटाने की आवश्यकता होती है। नीति इंटरफ़ेस पैरामीटर डिज़ाइन किया जा सकता है।isReset, और फिर नीति में आरंभिक भाग को पुनः डिज़ाइन करने के लिए कोड को रीसेट करें, जैसेः

    if (isReset) {   // 当isReset为真时重置数据
        _G(null)
        LogReset(1)
        LogProfitReset()
        LogVacuum()
        Log("重置所有数据", "#FF0000")
    }
  

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

  उदाहरण के लिए, निम्न कोडः

    var nowAccs = _C(updateAccs, exchanges)
    var initAccs = _G("initAccs")
    if (!initAccs) {
        initAccs = nowAccs
        _G("initAccs", initAccs)
    }
  

लेनदेन तर्क, मुख्य फ़ंक्शन में मुख्य चक्र

मुख्य लूप में कोड एक प्रक्रिया है जिसे नीतिगत तर्क के प्रत्येक चरण में निष्पादित किया जाता है, और लगातार दोहराए जाने वाले निष्पादन एक नीतिगत लूप का गठन करते हैं। आइए देखें कि मुख्य लूप में प्रोग्राम प्रत्येक बार क्या निष्पादित करता है।

• बाजार डेटा प्राप्त करें और बाजार डेटा की प्रभावशीलता का आकलन करें

        var ts = new Date().getTime()
        var depthARoutine = exA.Go("GetDepth")
        var depthBRoutine = exB.Go("GetDepth")
        var depthA = depthARoutine.wait()
        var depthB = depthBRoutine.wait()
        if (!depthA || !depthB || depthA.Asks.length == 0 || depthA.Bids.length == 0 || depthB.Asks.length == 0 || depthB.Bids.length == 0) {
            Sleep(500)
            continue 
        }
  

  यहाँ आप FMZ प्लेटफ़ॉर्म का उपयोग करते हुए समवर्ती कार्य देख सकते हैं।exchange.Go, एक कॉल बनायाGetDepth()इंटरफ़ेस के समवर्ती ऑब्जेक्टdepthARoutine、depthBRoutine◎ जब ये दो समवर्ती ऑब्जेक्ट बनाए जाते हैं, तो कॉल करेंGetDepth()इंटरफेस भी तुरंत हुआ, जब दोनों अनुरोधों को एक्सचेंजों को गहराई से डेटा प्राप्त करने के लिए भेजा गया। और फिर कॉल करेंdepthARoutine、depthBRoutineवस्तुओंwait()गहन डेटा प्राप्त करने के तरीके।
  गहन डेटा प्राप्त करने के बाद, गहन डेटा की जांच करने की आवश्यकता होती है ताकि इसकी प्रभावशीलता का आकलन किया जा सके।continueवाक्य मुख्य चक्र को फिर से चलाता है।

• उपयोग价差值पैरामीटर या नहीं?差价比例पैरामीटर?

        var targetDiffPrice = hedgeDiffPrice
        if (diffAsPercentage) {
            targetDiffPrice = (depthA.Bids[0].Price + depthB.Asks[0].Price + depthB.Bids[0].Price + depthA.Asks[0].Price) / 4 * hedgeDiffPercentage
        }
  

  FMZ के पैरामीटर किसी पैरामीटर पर आधारित हो सकते हैं।दिखाएँयाछिपा हुआतो हम एक पैरामीटर बनाने के लिए यह तय करने के लिए कि क्या इस्तेमाल किया जा सकता है.价格差, या差价比例。

  

  रणनीति इंटरफ़ेस पैरामीटर पर एक पैरामीटर जोड़ा गयाdiffAsPercentageइस पैरामीटर के आधार पर प्रदर्शित या छिपे हुए दो अन्य पैरामीटर सेट हैंःhedgeDiffPrice@!diffAsPercentage, जबdiffAsPercentageइस पैरामीटर को प्रदर्शित करने के लिए गलत।hedgeDiffPercentage@diffAsPercentage, जबdiffAsPercentageइस पैरामीटर को सही दिखाएं. इस तरह के डिजाइन के बाद, हमने चयन किया।diffAsPercentageपैरामीटर, जो कि मूल्य अंतर अनुपात के अनुसार हेजिंग के लिए ट्रिगर की स्थिति है।diffAsPercentageपैरामीटर एक मूल्य अंतर है जो एक हेजिंग के रूप में ट्रिगर होता है।

• हेजिंग ट्रिगर की शर्तों का निर्धारण

        if (depthA.Bids[0].Price - depthB.Asks[0].Price > targetDiffPrice && Math.min(depthA.Bids[0].Amount, depthB.Asks[0].Amount) >= minHedgeAmount) {          // A -> B 盘口条件满足            
            var price = (depthA.Bids[0].Price + depthB.Asks[0].Price) / 2
            var amount = Math.min(depthA.Bids[0].Amount, depthB.Asks[0].Amount)
            if (nowAccs[0].Stocks > minHedgeAmount && nowAccs[1].Balance / price > minHedgeAmount) {
                amount = Math.min(amount, nowAccs[0].Stocks, nowAccs[1].Balance / price, maxHedgeAmount)
                Log("触发A->B:", depthA.Bids[0].Price - depthB.Asks[0].Price, price, amount, nowAccs[1].Balance / price, nowAccs[0].Stocks)  // 提示信息
                hedge(exB, exA, price, amount)
                cancelAll()
                lastKeepBalanceTS = 0
                isTrade = true 
            }            
        } else if (depthB.Bids[0].Price - depthA.Asks[0].Price > targetDiffPrice && Math.min(depthB.Bids[0].Amount, depthA.Asks[0].Amount) >= minHedgeAmount) {   // B -> A 盘口条件满足
            var price = (depthB.Bids[0].Price + depthA.Asks[0].Price) / 2
            var amount = Math.min(depthB.Bids[0].Amount, depthA.Asks[0].Amount)
            if (nowAccs[1].Stocks > minHedgeAmount && nowAccs[0].Balance / price > minHedgeAmount) {
                amount = Math.min(amount, nowAccs[1].Stocks, nowAccs[0].Balance / price, maxHedgeAmount)
                Log("触发B->A:", depthB.Bids[0].Price - depthA.Asks[0].Price, price, amount, nowAccs[0].Balance / price, nowAccs[1].Stocks)  // 提示信息
                hedge(exA, exB, price, amount)
                cancelAll()
                lastKeepBalanceTS = 0
                isTrade = true 
            }            
        }
  

  यह एक बहुत ही महत्वपूर्ण कदम है, लेकिन यह एक बहुत ही महत्वपूर्ण कदम है। 1, सबसे पहले एक हेजिंग डिफरेंस को पूरा किया जाता है, और केवल तभी हेजिंग की जा सकती है जब एक डिलीवरी का डिफरेंस सेट किए गए डिफरेंस पैरामीटर को पूरा करता है । 2. लेन-देन के लिए उपलब्ध हैक को न्यूनतम हैक को पूरा करना चाहिए जो पैरामीटर पर सेट किया गया है, क्योंकि विभिन्न एक्सचेंजों द्वारा सीमित होने वाली न्यूनतम मात्रा अलग-अलग हो सकती है, इसलिए दोनों में से सबसे कम लेना चाहिए। 3। लेन-देन करने वाले एक्सचेंज में पर्याप्त संपत्ति बेचने के लिए, लेन-देन करने वाले एक्सचेंज में पर्याप्त संपत्ति खरीदने के लिए। जब ये शर्तें पूरी हो जाती हैं, तो एक हेजिंग फ़ंक्शन निष्पादित किया जाता है। हम मुख्य फ़ंक्शन से पहले एक चर घोषित करते हैं।isTradeयह पता लगाने के लिए कि क्या कोई हेजिंग है, अगर यह ट्रिगर होता है, तो यह चर सेट करेंtrueऔर वैश्विक चर को रीसेट करेंlastKeepBalanceTS0 (lastKeepBalanceTS का उपयोग हाल के संतुलन ऑपरेशन के समय चिह्न के लिए किया जाता है, जिसे 0 पर सेट करने से संतुलन ऑपरेशन तुरंत शुरू हो जाता है) और फिर सभी लंबित सूची को रद्द करें।

• संतुलन संचालन

        if (ts - lastKeepBalanceTS > keepBalanceCyc * 1000) {
            nowAccs = _C(updateAccs, exchanges)
            var isBalance = keepBalance(initAccs, nowAccs, [depthA, depthB])
            cancelAll()
            if (isBalance) {
                lastKeepBalanceTS = ts
                if (isTrade) {
                    var nowBalance = _.reduce(nowAccs, function(sumBalance, acc) {return sumBalance + acc.Balance}, 0)
                    var initBalance = _.reduce(initAccs, function(sumBalance, acc) {return sumBalance + acc.Balance}, 0)
                    LogProfit(nowBalance - initBalance, nowBalance, initBalance, nowAccs)
                    isTrade = false 
                }                
            }            
        }
  

  आप देख सकते हैं कि संतुलन फ़ंक्शन नियमित रूप से निष्पादित होता है, लेकिन अगर हेजिंग ऑपरेशन ट्रिगर हो जाता है,lastKeepBalanceTS0 पर रीसेट होने पर, संतुलन ऑपरेशन तुरंत शुरू हो जाता है; संतुलन सफल होने के बाद, लाभ की गणना की जाती है।

• स्थिति टैब जानकारी

        LogStatus(_D(), "A->B:", depthA.Bids[0].Price - depthB.Asks[0].Price, " B->A:", depthB.Bids[0].Price - depthA.Asks[0].Price, " targetDiffPrice:", targetDiffPrice, "\n", 
            "当前A，Stocks:", nowAccs[0].Stocks, "FrozenStocks:", nowAccs[0].FrozenStocks, "Balance:", nowAccs[0].Balance, "FrozenBalance", nowAccs[0].FrozenBalance, "\n", 
            "当前B，Stocks:", nowAccs[1].Stocks, "FrozenStocks:", nowAccs[1].FrozenStocks, "Balance:", nowAccs[1].Balance, "FrozenBalance", nowAccs[1].FrozenBalance, "\n", 
            "初始A，Stocks:", initAccs[0].Stocks, "FrozenStocks:", initAccs[0].FrozenStocks, "Balance:", initAccs[0].Balance, "FrozenBalance", initAccs[0].FrozenBalance, "\n", 
            "初始B，Stocks:", initAccs[1].Stocks, "FrozenStocks:", initAccs[1].FrozenStocks, "Balance:", initAccs[1].Balance, "FrozenBalance", initAccs[1].FrozenBalance)
  

  स्थिति पट्टी का डिज़ाइन विशेष रूप से जटिल नहीं है, यह वर्तमान समय को दर्शाता है, एक्सचेंज ए से एक्सचेंज बी और एक्सचेंज बी से एक्सचेंज ए के बीच का अंतर दिखाता है। यह वर्तमान हेजिंग लक्ष्य अंतर दिखाता है। यह एक्सचेंज ए के खाते में परिसंपत्ति डेटा, एक्सचेंज बी के खाते में परिसंपत्ति डेटा दिखाता है।

अलग-अलग मुद्राओं के लिए लेनदेन जोड़े का प्रबंधन

और हम एक पैरामीटर है कि हम विनिमय दरों को परिवर्तित करने के लिए बनाया है, और हम शुरू में रणनीति के साथ शुरू करते हैं।mainहम भी विनिमय दर परिवर्तित करने के लिए डिजाइन किया है.SetRateविनिमय दर रूपांतरण फ़ंक्शन को पहले निष्पादित करने की आवश्यकता है। क्योंकि यह फ़ंक्शन दो स्तरों को प्रभावित करता हैः

• सभी बाजार डेटा, ऑर्डर डेटा, स्टॉक डेटा में मूल्य विनिमय।
• खाता परिसंपत्तियों में मूल्यवान मुद्राओं का आदान-प्रदान। उदाहरण के लिए, वर्तमान लेन-देन जोड़ेBTC_USDTकीमतों की इकाइयांUSDTखाता परिसंपत्तियों में उपयोग की जाने वाली मुद्रा भी है।USDT⇒ यदि मैं CNY में एक संख्या बदलना चाहता हूं, तो कोड में सेट करेंexchange.SetRate(6.8)इसे हटा देंexchangeइस एक्सचेंज ऑब्जेक्ट के तहत प्राप्त सभी फ़ंक्शन डेटा को CNY में परिवर्तित किया जाता है। और यह कि क्यों मूल्य निर्धारण के लिए?SetRateफ़ंक्शन का प्रवेशवर्तमान मूल्य के लिए लक्ष्य मूल्य के लिए विनिमय दर。

पूरी रणनीतिःविभिन्न मुद्राओं के लिए नकदी हेजिंग रणनीतियाँ (शिक्षा)