नौसिखिया, इसे देखें आपको क्रिप्टोकरेंसी मात्रात्मक व्यापार में ले जाएं (6)

नौसिखिया, इसे देखें आपको क्रिप्टोकरेंसी मात्रात्मक व्यापार में ले जाएं (6)

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

रणनीति आवश्यकता के आधार पर डिजाइन के बारे में सोचना

इस लेख में, पिछले एक की तरह ही, हम एफएमजेड क्वांट ट्रेडिंग प्लेटफॉर्म पर आधारित डिजाइन के बारे में चर्चा करते हैं (FMZ.COM).

• कई प्रतीक ईमानदार होने के लिए, मैं चाहता हूँ कि ग्रिड रणनीति न केवलBTC_USDT, लेकिन यह भीLTC_USDT/EOS_USDT/DOGE_USDT/ETC_USDT/ETH_USDT. वैसे भी, स्पॉट ट्रेडिंग जोड़े के लिए, एक ही समय में आप व्यापार करना चाहते हैं कि सभी प्रतीकों के ग्रिड व्यापार संचालित.

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

  • 1. सबसे पहले, कई प्रतीकों के बाजार उद्धरण प्राप्त करना. यह हल करने के लिए पहली समस्या है. मंच एपीआई प्रलेखन पढ़ने के बाद, मुझे पता चला कि प्लेटफार्मों आमतौर पर एकत्रित इंटरफेस प्रदान करते हैं. ठीक है, हम एकत्रित बाजार डेटा इंटरफ़ेस का उपयोग डेटा प्राप्त करने के लिए करते हैं.
  • 2. दूसरी समस्या खाता संपत्ति है. हम बहु-प्रतीक रणनीतियों को निष्पादित करना चाहते हैं के लिए, हम अलग से प्रत्येक व्यापार जोड़ी की संपत्ति का प्रबंधन करने पर विचार करना चाहिए, और सभी संपत्ति डेटा प्राप्त और इसे एक बार रिकॉर्ड. क्यों हम खाता संपत्ति डेटा प्राप्त करना चाहिए? और क्यों भी अलग से प्रत्येक व्यापार जोड़ी रिकॉर्ड?

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

  • 3. रणनीति पैरामीटर डिजाइन. बहु-प्रतीक रणनीति का पैरामीटर डिजाइन एकल-प्रतीक एक के पैरामीटर डिजाइन से काफी अलग है, क्योंकि बहु-प्रतीक रणनीति में प्रत्येक प्रतीक का ट्रेडिंग तर्क भी समान है, यह संभव है कि ट्रेडिंग के दौरान प्रत्येक प्रतीक के पैरामीटर अलग-अलग हों। उदाहरण के लिए, ग्रिड रणनीति में, आप BTC_USDT ट्रेडिंग जोड़ी करते समय हर बार 0.01 BTC का व्यापार करना चाह सकते हैं, लेकिन DOGE_USDT करते समय इस पैरामीटर (0.01 मुद्रा का व्यापार) का उपयोग करना स्पष्ट रूप से अनुचित है। बेशक, आप USDT की राशि द्वारा भी संसाधित कर सकते हैं। लेकिन फिर भी समस्याएं होंगी। क्या होगा यदि आप BTC_USDT द्वारा 1000U और DOGE_USDT द्वारा 10U का व्यापार करना चाहते हैं? मांग कभी भी संतुष्ट नहीं हो सकती है। शायद, कुछ छात्र इस प्रश्न के बारे में सोच सकते हैं, और यह प्रस्ताव कर सकते हैं कि, मैं पैरामीटर के अधिक समूह सेट कर सकता हूं, और अलग-अलग ट्रेडिंग जोड़े के पैरामीटर को अलग से नियंत्रित कर सकता हूं। कि अभी भी लचीले ढंग से आवश्यकता को पूरा नहीं कर सकते हैं, कितने पैरामीटर के समूह निर्धारित किया जाना चाहिए के लिए? हम सेट 3 समूहों; क्या अगर हम 4 प्रतीकों संचालित करना चाहते हैं? क्या हम रणनीति को संशोधित करने और पैरामीटर बढ़ाने की जरूरत है? इसलिए, बहु-प्रतीक रणनीति मापदंडों को डिजाइन करते समय विभेदन की आवश्यकता के बारे में पूरी तरह से सोचें। एक समाधान मापदंडों को सामान्य स्ट्रिंग्स या JSON स्ट्रिंग्स में डिजाइन करना है।
       उदाहरण के लिए:

    ETHUSDT:100:0.002|LTCUSDT:20:0.1
    

    प्रत्येक प्रतीक के डेटा को विभाजित करने के लिए का प्रयोग किया जाता है, जो दर्शाता है किETHUSDT:100:0.002ट्रेडिंग जोड़ी ETH_USDT को नियंत्रित करता है, औरLTCUSDT:20:0.1व्यापारिक जोड़ी LTC_USDT को नियंत्रित करता है। मध्य में goba विभाजन की भूमिका निभाता है। अंदरETHUSDT:100:0.002, ETHUSDT ट्रेडिंग जोड़ी का प्रतिनिधित्व करता है जिसे आप संचालित करना चाहते हैं; 100 ग्रिड अंतराल है; 0.002 प्रत्येक ग्रिड की ट्रेड की गई ETH राशि है; : का उपयोग ऊपर उल्लिखित डेटा को विभाजित करने के लिए किया जाता है (निश्चित रूप से, पैरामीटर के नियम रणनीति डिजाइनर द्वारा बनाए जाते हैं; आप अपनी आवश्यकता के आधार पर जो कुछ भी चाहते हैं उसे डिज़ाइन कर सकते हैं) ।
    इन स्ट्रिंग्स में पहले से ही प्रत्येक प्रतीक की पैरामीटर जानकारी है जिसे आपको संचालित करने की आवश्यकता है। आप स्ट्रिंग्स को पार्स कर सकते हैं, और प्रत्येक प्रतीक के ट्रेडिंग लॉजिक को नियंत्रित करने के लिए रणनीति में चर को मान असाइन कर सकते हैं। कैसे पार्स करें? आइए ऊपर दिए गए उदाहरण का उपयोग करें।

    function main() {
        var net = []  // the recorded grid parameters; when specifically running the grid trading logic, use the data from here 
        var params = "ETHUSDT:100:0.002|LTCUSDT:20:0.1"
        var arrPair = params.split("|")
        _.each(arrPair, function(pair) {
            var arr = pair.split(":")
            var symbol = arr[0]              // trading pair name 
            var diff = parseFloat(arr[1])    // grid spacing 
            var amount = parseFloat(arr[2])  // grid order amount 
            net.push({symbol : symbol, diff : diff, amount : amount})
        })
        Log("Grid parameter data:", net)
    }
    

    

    देखो, हम पैरामीटर पार्स किया है. निश्चित रूप से, आप सीधे JSON स्ट्रिंग का उपयोग कर सकते हैं, जो आसान है.

    function main() {        
        var params = '[{"symbol":"ETHUSDT","diff":100,"amount":0.002},{"symbol":"LTCUSDT","diff":20,"amount":0.1}]'
        var net = JSON.parse(params)  // the recorded grid parameters; when specifically running the grid trading logic, use the data from here         
        _.each(net, function(pair) {
            Log("Trading pair:", pair.symbol, pair)
        })
    }
    

    

  • 4. डेटा स्थिरता एक व्यावहारिक रणनीति और एक शिक्षण रणनीति के बीच एक बड़ा अंतर है। पिछले लेख में शिक्षण रणनीति केवल रणनीति तर्क और डिजाइन के प्रारंभिक परीक्षण के लिए है। जब वास्तव में एक बॉट में एक रणनीति चलाने के बारे में चिंता करने के लिए अधिक समस्याएं हैं। जब एक बॉट चलाने के लिए, बॉट शुरू किया जा सकता है और रोक दिया जा सकता है। उस समय, बॉट चलाने के दौरान सभी डेटा खो जाएगा। तो, कैसे बॉट को फिर से शुरू करते समय पिछली स्थिति को जारी रखने के लिए, बॉट बंद कर दिया गया है के बाद? यहाँ, जब बॉट चल रहा है तो कुंजी डेटा को लगातार सहेजना आवश्यक है, ताकि डेटा पढ़ा जा सके और बॉट को फिर से शुरू करने पर बॉट चलना जारी रखे। आप का उपयोग कर सकते हैं_G()FMZ Quant पर फ़ंक्शन, या ऑपरेशन फ़ंक्शन का उपयोग करेंDBExec()डेटाबेस में, और आप विवरण के लिए FMZ एपीआई प्रलेखन पूछ सकते हैं.

    उदाहरण के लिए, हम फ़ंक्शन का उपयोग करके एक सफाई समारोह डिजाइन करना चाहते हैं_G(), ग्रिड डेटा को बचाने के लिए।

    var net = null 
    function main() {  // strategy main function 
        // first read the stored net 
        net = _G("net")
        
        // ...
    }
    
    function onExit() {
        _G("net", net)
        Log("Execute the clean-up processing, and save the data", "#FF0000")
    }
    
    function onexit() {    // the onexit function defined by the platform system, which will be triggered when clicking the bot to stop 
        onExit()
    }
    
    function onerror() {   // the onerror function defined by the platform system, which will be triggered when the program exception occurs 
        onExit()
    }
    

  • 5. आदेश राशि की सटीकता, आदेश मूल्य की सटीकता, न्यूनतम आदेश मात्रा, न्यूनतम आदेश राशि आदि पर सीमाएँ।

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

    बहु-प्रतीक मामलों के लिए, आवश्यकता अधिक जटिल है। एकल-प्रतीक रणनीति के लिए, आप सटीकता जैसी जानकारी निर्दिष्ट करने के लिए एक पैरामीटर डिजाइन कर सकते हैं। हालांकि, जब आप एक बहु-प्रतीक रणनीति डिजाइन करते हैं, तो यह स्पष्ट है कि एक पैरामीटर में जानकारी लिखना पैरामीटर को बहुत थकाऊ बना देगा।

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

  • 6. विभिन्न प्लेटफार्मों का अनुकूलन अंत में समस्या का उल्लेख क्यों किया गया है? उपरोक्त सभी समस्याओं को हल करने से अंतिम समस्या का सामना करना पड़ेगा। क्योंकि हम रणनीति में समग्र बाजार इंटरफ़ेस का उपयोग करने की योजना बना रहे हैं। चूंकि हमारी रणनीति समग्र बाजार इंटरफेस का उपयोग करने की योजना बना रही है, इसलिए प्लेटफॉर्म ट्रेडिंग जोड़ी सटीकता और अन्य डेटा अनुकूलन तक पहुंच जैसे समाधान, साथ ही प्रत्येक ट्रेडिंग जोड़ी को अलग से संसाधित करने के लिए खाता जानकारी तक पहुंच आदि, विभिन्न प्लेटफार्मों के कारण बड़े अंतर लाएंगे। इंटरफेस कॉल में अंतर और तंत्र में अंतर हैं। स्पॉट प्लेटफार्मों के लिए, यदि ग्रिड रणनीति को वायदा संस्करण तक बढ़ाया जाता है तो अंतर अपेक्षाकृत छोटा होता है। प्रत्येक मंच के तंत्र में अंतर और भी बड़ा होता है। एक समाधान एक एफएमजेड टेम्पलेट लाइब्रेरी डिजाइन करना है; रणनीति और मंच के बीच युग्मन को कम करने के लिए लाइब्रेरी में अंतर को लागू करने का डिज़ाइन लिखें। इसका नुकसान यह है कि आपको एक टेम्पलेट लाइब्रेरी लिखने की आवश्यकता है, और इस टेम्पलेट में, विशेष रूप से प्रत्येक प्लेटफॉर्म के आधार पर भेदभाव को लागू करें।

टेम्पलेट लाइब्रेरी डिज़ाइन करें

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

function createBaseEx(e, funcConfigure) {
    var self = {}
    self.e = e 
    
    self.funcConfigure = funcConfigure
    self.name = e.GetName()
    self.type = self.name.includes("Futures_") ? "Futures" : "Spot"
    self.label = e.GetLabel()
    
    // the interfaces that need to be implemented 
    self.interfaceGetTickers = null   // create a function that asynchronously obtains the aggregated market quote threads
    self.interfaceGetAcc = null       // create a function that asynchronously obtains the account data threads 
    self.interfaceGetPos = null       // obtain positions 
    self.interfaceTrade = null        // create concurrent orders 
    self.waitTickers = null           // wait for the concurrent market quote data  
    self.waitAcc = null               // wait for the account concurrent data 
    self.waitTrade = null             // wait for order concurrent data
    self.calcAmount = null            // calculate the order amount according to the trading pair precision and other data 
    self.init = null                  // initialization; obtain the precision and other data 
    
    // execute the configuration function, to configure objects 
    funcConfigure(self)

    // detect whether all the interfaces arranged by configList can be implemented 
    _.each(configList, function(funcName) {
        if (!self[funcName]) {
            throw "interface" + funcName + "not implemented"
        }
    })
    
    return self
}

$.createBaseEx = createBaseEx
$.getConfigureFunc = function(exName) {
    dicRegister = {
        "Futures_OKCoin" : funcConfigure_Futures_OKCoin,    //  the implementation of OKEX Futures 
        "Huobi" : funcConfigure_Huobi,
        "Futures_Binance" : funcConfigure_Futures_Binance,
        "Binance" : funcConfigure_Binance,
        "WexApp" : funcConfigure_WexApp,                    // the implementation of wexApp
    }
    return dicRegister
}

टेम्पलेट में, एक विशिष्ट प्लेफॉर्म के उद्देश्य से कोड लेखन को लागू करें; उदाहरण के रूप में FMZ सिमुलेटेड बॉट WexApp को लेंः

function funcConfigure_WexApp(self) {
    var formatSymbol = function(originalSymbol) {
        // BTC_USDT
        var arr = originalSymbol.split("_")
        var baseCurrency = arr[0]
        var quoteCurrency = arr[1]
        return [originalSymbol, baseCurrency, quoteCurrency]
    }

    self.interfaceGetTickers = function interfaceGetTickers() {
        self.routineGetTicker = HttpQuery_Go("https://api.wex.app/api/v1/public/tickers")
    }

    self.waitTickers = function waitTickers() {
        var ret = []
        var arr = JSON.parse(self.routineGetTicker.wait()).data
        _.each(arr, function(ele) {
            ret.push({
                bid1: parseFloat(ele.buy), 
                bid1Vol: parseFloat(-1),
                ask1: parseFloat(ele.sell), 
                ask1Vol: parseFloat(-1),
                symbol: formatSymbol(ele.market)[0],
                type: "Spot", 
                originalSymbol: ele.market
            })
        })
        return ret 
    }

    self.interfaceGetAcc = function interfaceGetAcc(symbol, updateTS) {
        if (self.updateAccsTS != updateTS) {
            self.routineGetAcc = self.e.Go("GetAccount")
        }
    }

    self.waitAcc = function waitAcc(symbol, updateTS) {
        var arr = formatSymbol(symbol)
        var ret = null 
        if (self.updateAccsTS != updateTS) {
            ret = self.routineGetAcc.wait().Info
            self.bufferGetAccRet = ret 
        } else {
            ret = self.bufferGetAccRet
        }
        if (!ret) {
            return null 
        }        
        var acc = {symbol: symbol, Stocks: 0, FrozenStocks: 0, Balance: 0, FrozenBalance: 0, originalInfo: ret}
        _.each(ret.exchange, function(ele) {
            if (ele.currency == arr[1]) {
                // baseCurrency
                acc.Stocks = parseFloat(ele.free)
                acc.FrozenStocks = parseFloat(ele.frozen)
            } else if (ele.currency == arr[2]) {
                // quoteCurrency
                acc.Balance = parseFloat(ele.free)
                acc.FrozenBalance = parseFloat(ele.frozen)
            }
        })
        return acc
    }

    self.interfaceGetPos = function interfaceGetPos(symbol, price, initSpAcc, nowSpAcc) {
        var symbolInfo = self.getSymbolInfo(symbol)
        var sumInitStocks = initSpAcc.Stocks + initSpAcc.FrozenStocks
        var sumNowStocks = nowSpAcc.Stocks + nowSpAcc.FrozenStocks
        var diffStocks = _N(sumNowStocks - sumInitStocks, symbolInfo.amountPrecision)
        if (Math.abs(diffStocks) < symbolInfo.min / price) {
            return []
        }
        return [{symbol: symbol, amount: diffStocks, price: null, originalInfo: {}}]
    }

    self.interfaceTrade = function interfaceTrade(symbol, type, price, amount) {
        var tradeType = ""
        if (type == self.OPEN_LONG || type == self.COVER_SHORT) {
            tradeType = "bid"
        } else {
            tradeType = "ask"
        }
        var params = {
            "market": symbol,
            "side": tradeType,
            "amount": String(amount),
            "price" : String(-1),
            "type" : "market"
        }
        self.routineTrade = self.e.Go("IO", "api", "POST", "/api/v1/private/order", self.encodeParams(params))
    }

    self.waitTrade = function waitTrade() {
        return self.routineTrade.wait()
    }

    self.calcAmount = function calcAmount(symbol, type, price, amount) {
        // obtain the trading pair information 
        var symbolInfo = self.getSymbolInfo(symbol)
        if (!symbol) {
            throw symbol + "，trading pair information not found"
        }
        var tradeAmount = null 
        var equalAmount = null  // record the symbol amount  
        if (type == self.OPEN_LONG || type == self.COVER_SHORT) {
            tradeAmount = _N(amount * price, parseFloat(symbolInfo.pricePrecision))
            // detect the minimum trading amount 
            if (tradeAmount < symbolInfo.min) {
                Log(self.name, " tradeAmount:", tradeAmount, "less than", symbolInfo.min)
                return false 
            }
            equalAmount = tradeAmount / price
        } else {
            tradeAmount = _N(amount, parseFloat(symbolInfo.amountPrecision))
            // detect the minimum trading amount 
            if (tradeAmount < symbolInfo.min / price) {
                Log(self.name, " tradeAmount:", tradeAmount, "less than", symbolInfo.min / price)
                return false 
            }
            equalAmount = tradeAmount
        }
        return [tradeAmount, equalAmount]
    }

    self.init = function init() {   // the function that automatically processes conditions like precision, etc.  
        var ret = JSON.parse(HttpQuery("https://api.wex.app/api/v1/public/markets"))
        _.each(ret.data, function(symbolInfo) {
            self.symbolsInfo.push({
                symbol: symbolInfo.pair,
                amountPrecision: parseFloat(symbolInfo.basePrecision),
                pricePrecision: parseFloat(symbolInfo.quotePrecision),
                multiplier: 1,
                min: parseFloat(symbolInfo.minQty),
                originalInfo: symbolInfo
            })
        })        
    }
}

रणनीति में टेम्पलेट का उपयोग करना बहुत आसान होगा:

function main() {
    var fuExName = exchange.GetName()
    var fuConfigureFunc = $.getConfigureFunc()[fuExName]
    var ex = $.createBaseEx(exchange, fuConfigureFunc)

    var arrTestSymbol = ["LTC_USDT", "ETH_USDT", "EOS_USDT"]
    var ts = new Date().getTime()
    
    // test to obtain the market quotes 
    ex.goGetTickers()
    var tickers = ex.getTickers()
    Log("tickers:", tickers)
    
    // test to obtain the account information 
    ex.goGetAcc(symbol, ts)
    
    _.each(arrTestSymbol, function(symbol) {        
        _.each(tickers, function(ticker) {
            if (symbol == ticker.originalSymbol) {
                // print the market quote data 
                Log(symbol, ticker)
            }
        })

        // print asset data 
        var acc = ex.getAcc(symbol, ts)
        Log("acc:", acc.symbol, acc)
    })
}

रणनीति बॉट

ऊपर दिए गए टेम्पलेट के आधार पर रणनीति को डिजाइन और लिखना बहुत सरल है। पूरी रणनीति में कोड की लगभग 300 लाइनें हैं। जो एक क्रिप्टोक्यूरेंसी स्पॉट मल्टी-सिंबल ग्रिड रणनीति को लागू करती है।

अभी, यह नुकसान हैT_T, इसलिए स्रोत कोड प्रदान नहीं किया जाएगा।

कई पंजीकरण कोड हैं; यदि आप रुचि रखते हैं, तो आप उन्हें wexApp में आज़मा सकते हैंः

Purchase Address: https://www.fmz.com/m/s/284507
Registration Code：
adc7a2e0a2cfde542e3ace405d216731
f5db29d05f57266165ce92dc18fd0a30
1735dca92794943ddaf277828ee04c27
0281ea107935015491cda2b372a0997d
1d0d8ef1ea0ea1415eeee40404ed09cc

वहाँ केवल 200 USD से अधिक था, और जब बॉट अभी शुरू किया गया था, तो यह एक महान एकतरफा बाजार में आया था। इसे नुकसान को कवर करने के लिए समय की आवश्यकता है। स्पॉट ग्रिड रणनीति का सबसे बड़ा लाभ यह हैः सुरक्षित महसूस करें! रणनीति की स्थिरता ठीक है, और मैंने 27 मई के बाद से इसे संशोधित नहीं किया है। मैं अस्थायी रूप से वायदा ग्रिड रणनीति का प्रयास करने की हिम्मत नहीं करता।