ब्लॉकचेन क्वांटिटेटिव इन्वेस्टमेंट सीरीज कोर्स (3) कैलेंडर स्प्रेड आर्बिट्रेज

NO.1 सोरोस द्वारा 1987 में लिखी गई पुस्तक वित्तीय रसायन शास्त्र में एक महत्वपूर्ण प्रस्ताव रखा गया था: मेरा मानना है कि बाजार की कीमतें हमेशा इस अर्थ में गलत होती हैं कि वे भविष्य का पक्षपाती दृष्टिकोण प्रस्तुत करती हैं। बाजार वैधता परिकल्पना केवल एक सैद्धांतिक धारणा है। वास्तव में, बाजार के प्रतिभागी हमेशा तर्कसंगत नहीं होते हैं, और प्रत्येक बिंदु पर, प्रतिभागी पूरी तरह से प्राप्त नहीं कर सकते हैं और सभी जानकारी की वस्तुनिष्ठ व्याख्या नहीं कर सकते हैं। भले ही यह एक ही जानकारी हो, हर किसी की प्रतिक्रिया अलग है।

दूसरे शब्दों में, मूल्य में ही बाजार के प्रतिभागियों की गलत अपेक्षाएं होती हैं, इसलिए मूल रूप से बाजार मूल्य हमेशा गलत होता है। यह मध्यस्थों के लिए लाभ का स्रोत हो सकता है।

NO.2 उपरोक्त सिद्धांतों के आधार पर हम यह भी जानते हैं कि अप्रभावी वायदा बाजार में, विभिन्न अवधियों में वितरण अनुबंधों का बाजार प्रभाव हमेशा सिंक्रनाइज़ नहीं होता है, और मूल्य निर्धारण पूरी तरह से प्रभावी होने का कारण नहीं है।

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

उदाहरण के लिए, मान लीजिए कि ईटीसी सप्ताह और ईटीसी तिमाही के बीच का स्प्रेड लंबे समय तक लगभग 5 पर बनाए रखा जाता है। यदि स्प्रेड 7 तक पहुंच जाता है, तो हम भविष्य में किसी समय स्प्रेड को 5 पर लौटने की उम्मीद करते हैं। फिर आप ईटीसी सप्ताह बेच सकते हैं और स्प्रेड को छोटा करने के लिए ईटीसी तिमाही खरीद सकते हैं। इसके विपरीत।

NO.3 यद्यपि यह स्प्रेड मौजूद है, लेकिन मैन्युअल आर्बिट्रेज में अक्सर समय लेने वाले, कम सटीक मैन्युअल ऑपरेशन और मूल्य परिवर्तन प्रभावों के कारण कई अनिश्चितताएं होती हैं।

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

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

NO.4 एक डिजिटल मुद्रा अंतराल-समय मध्यस्थता रणनीति बनाएँ कठिनाईः सामान्य स्तर रणनीतिक माहौल: लेनदेन का लक्ष्यः Ethereum classic (ETC) स्प्रेड डेटा: ईटीसी साप्ताहिक - ईटीसी त्रैमासिक व्यापार अवधिः 5 मिनट स्थिति मिलानः 1:1 लेन-देन का प्रकार: एक ही प्रकार का अंतराल रणनीतिक तर्क: लंबी स्प्रेड स्थिति की खरीद की शर्तेंः यदि चालू खाते में कोई स्थिति नहीं है, और स्प्रेड बॉल संकेतक के नीचे के निशान से कम है, तो एक स्प्रेड ऑर्डर रखें, जो हैः ईटीसी की लंबी खरीद साप्ताहिक, ईटीसी की छोटी बिक्री त्रैमासिक।

शॉर्ट-सेलिंग स्प्रेड पोजीशन की शर्तेंः यदि चालू खाते में कोई पोजीशन नहीं है और स्प्रेड बॉल इंडिकेटर के अप रेल से अधिक है, तो स्प्रेड ऑर्डर दें, जो कि हैः ईटीसी को साप्ताहिक रूप से शॉर्ट बेचना, ईटीसी को त्रैमासिक रूप से खरीदना।

खरीद-लंबी स्प्रेड स्थिति की शर्त बंद करनाः यदि चालू खाते में एक लंबी ईटीसी साप्ताहिक स्थिति है और एक छोटी ईटीसी त्रैमासिक स्थिति है, और स्प्रेड बॉल संकेतक के मध्य रेल से अधिक है, तो एक बंद स्प्रेड ऑर्डर रखें, जो हैः ईटीसी साप्ताहिक बेचें, ईटीसी को कवर करने के लिए तिमाही खरीदें।

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

NO.5 उपरोक्त डिजिटल मुद्रा अंतरकालिक मध्यस्थता रणनीति तर्क का एक सरल विवरण है, तो कार्यक्रम में अपने स्वयं के विचारों को लागू करने के लिए कैसे? हम एफएमजेड मात्रात्मक व्यापार मंच पर पहले ढांचे का निर्माण करने का प्रयास किया. रणनीतिक ढांचा:

रणनीतिक सोच और लेनदेन प्रक्रिया के अनुसार रणनीतिक ढांचे को आसानी से बनाया जा सकता है। पूरी रणनीति को तीन चरणों में सरल किया जा सकता हैः

1. लेन-देन से पहले पूर्व-प्रसंस्करण।
2. डेटा प्राप्त करें और गणना करें।
3. आदेश दें और अनुवर्ती कार्रवाई करें।

NO.6 इसके बाद, हमें वास्तविक लेनदेन प्रक्रिया और लेनदेन विवरण के आधार पर रणनीति ढांचे में आवश्यक विवरण भरने की आवश्यकता है।

सबसे पहले, लेनदेन से पहले पूर्व-प्रसंस्करण चरण 1: वैश्विक वातावरण में, आवश्यक वैश्विक चर घोषित करें। एक चार्ट ऑब्जेक्ट घोषित करें जो चार्ट को कॉन्फ़िगर करता है Var चार्ट = { } चार्ट को आरंभ करने के लिए चार्ट फ़ंक्शन को कॉल करें Var ObjChart = चार्ट (चार्ट) प्रसार अनुक्रम को संग्रहीत करने के लिए एक खाली सरणी घोषित करें Var बार = [ ] ऐतिहासिक डेटा रिकॉर्ड करने वाला टाइमस्टैम्प चर घोषित करें Var oldTime = 0 चरण 2: रणनीति के लिए बाहरी मापदंडों को कॉन्फ़िगर करें।

चरण 3: डेटा प्रोसेसिंग फ़ंक्शन को परिभाषित करें आधारभूत डेटा फ़ंक्शन: डेटा ()) एक कंस्ट्रक्टर डेटा बनाएँ और इसके आंतरिक गुणों को परिभाषित करें, जिसमें शामिल हैंः खाता डेटा, स्थिति डेटा, K-लाइन डेटा टाइमस्टैम्प, मध्यस्थता अनुबंध A/B की नवीनतम खरीद/बिक्री मूल्य, सकारात्मक/रिवर्स मध्यस्थता स्प्रेड

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

K रेखा और संकेतक कार्यः boll ()) सकारात्मक/विपरित आर्बिट्रेज स्प्रेड के डेटा के आधार पर एक नया के-लाइन अनुक्रम संश्लेषित करें। और बॉल संकेतक द्वारा गणना किए गए ऊपर/मध्य/नीचे रेल डेटा लौटाएं।

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

आदेश रद्द करें फ़ंक्शन: cancelOrders ()) सभी लंबित आदेशों की सरणी प्राप्त करें और उन्हें एक-एक करके रद्द करें. और यदि कोई लंबित आदेश है, तो झूठा लौटाएं, और यदि कोई नहीं है, तो सच लौटाएं.

प्रक्रिया धारण एकल अनुबंध: isEven ()) सिंगल लेग स्थिति के मामले में आर्बिट्रेज ट्रेडिंग में, यह सीधे सभी पदों को बंद करके संभाला जाता है। बेशक, आप कीमत का पीछा करने में भी बदल सकते हैं।

रेखाचित्र कार्य: रेखाचित्र ()) चार्ट में आवश्यक बाजार डेटा और संकेतक डेटा आकर्षित करने के लिए ObjChart.add () विधि को कॉल करेंः ऊपर, मध्य, नीचे रेल, सकारात्मक/विपरित आर्बिट्रेज स्प्रेड।

चरण 4: प्रविष्टि फ़ंक्शन main () में, लेनदेन से पहले पूर्व-प्रसंस्करण कोड निष्पादित करें, जो प्रोग्राम शुरू होने के बाद केवल एक बार चलाया जाता है, जिसमें शामिल हैंः

कंसोल सेटErrorFilter में बहुत महत्वपूर्ण नहीं है कि जानकारी फ़िल्टर ()) व्यापार करने के लिए डिजिटल मुद्रा प्रकार सेट करेंexchange.IO) प्रोग्राम शुरू करने से पहले खींचे गए चार्ट को खाली करें ObjChart.reset ()) प्रोग्राम प्रारंभ करने से पहले स्थिति पट्टी जानकारी को खाली करें LogProfitReset ())

NO.7 लेन-देन से पहले उपरोक्त पूर्व-प्रसंस्करण को परिभाषित करने के बाद, अगले चरण पर आगे बढ़ना आवश्यक है, मतदान मोड में प्रवेश करें, और onTick () फ़ंक्शन को दोहराएं। और मतदान करते समय नींद का समय सेट करें, क्योंकि कुछ डिजिटल मुद्रा विनिमय एपीआई में एक निश्चित अवधि के लिए अंतर्निहित पहुंच सीमा होती है।

दूसरा, डेटा प्राप्त करें और गणना करें चरण 1: ट्रेडिंग तर्क के लिए अंतर्निहित डेटा ऑब्जेक्ट, खाता शेष और बॉल सूचक डेटा प्राप्त करें।

तीसरा, आदेश दें और उसका पालन करें चरण 1: उपरोक्त रणनीति तर्क के अनुसार खरीद और बिक्री का संचालन करें। सबसे पहले, जांचें कि क्या मूल्य और संकेतक की स्थिति सही है, और फिर देखें कि क्या स्थिति की स्थिति सही है, और अंत में व्यापार () ऑर्डर फ़ंक्शन निष्पादित करें।

चरण 2: आदेश देने के बाद, लंबित आदेशों और एकल अनुबंध रखने जैसी असामान्य स्थितियों से निपटना और चार्ट बनाना आवश्यक है।

NO.8 ऊपर, हमने 200 से अधिक पंक्तियों के माध्यम से एक सरल डिजिटल मुद्रा अंतःकालिक मध्यस्थता रणनीति बनाई है। पूरा कोड निम्नानुसार हैः

NO.9 यह रणनीति सिर्फ एक ट्रिगर के रूप में कार्य करता है. वास्तविक बाजार इतना सरल नहीं है, लेकिन आप अपनी कल्पना के साथ खेलने के लिए इस उदाहरण का उपयोग कर सकते हैं.

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

इसका कारण यह है कि कोई फर्क नहीं पड़ता कि किस डिजिटल मुद्रा विनिमय के वायदा बाजार में, मार्जिन फिएट नहीं है। लगभग सभी डिजिटल मुद्राओं में वर्ष की शुरुआत के बाद से लगभग 70% की गिरावट आई है। दूसरे शब्दों में, रणनीति हमेशा मुद्रा बना रही है, लेकिन मुद्रा की कीमत गिर रही है।

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

यहाँ पूरा कोड प्राप्त करने के लिएः

// global variable
// Declare a chart object that configures the chart
var chart = {
    __isStock: true,
    tooltip: {
        xDateFormat: '%Y-%m-%d %H:%M:%S, %A'
    },
    title: {
        text: 'Profit and loss chart（detail）'
    },
    rangeSelector: {
        buttons: [{
            type: 'hour',
            count: 1,
            text: '1h'
        }, {
            type: 'hour',
            count: 2,
            text: '3h'
        }, {
            type: 'hour',
            count: 8,
            text: '8h'
        }, {
            type: 'all',
            text: 'All'
        }],
        selected: 0,
        inputEnabled: false
    },
    xAxis: {
        type: 'datetime'
    },
    yAxis: {
        title: {
            text: 'spread'
        },
        opposite: false,
    },
    series: [{
        name: "up",
        id: "line1,up",
        data: []
    }, {
        name: "middle",
        id: "line2,middle",
        data: []
    }, {
        name: "down",
        id: "line3,down",
        data: []
    }, {
        name: "basb",
        id: "line4,basb",
        data: []
    }, {
        name: "sabb",
        id: "line5,sabb",
        data: []
    }]
};
var ObjChart = Chart(chart); // Drawing object
var bars = []; // Store spread sequence
var oldTime = 0; // Record historical data timestamp

// Parameter
var tradeTypeA = "this_week"; // Arbitrage contract A
var tradeTypeB = "quarter"; // Arbitrage contract B
var dataLength = 10; //Length of indicator cycle
var timeCycle = 1; // The cycle of K-line
var name = "ETC"; // Currency type
var unit = 1; // Quantity of orders

// Basic data
function Data(tradeTypeA, tradeTypeB) { // input arbitrage contract A&B
    this.accountData = _C(exchange.GetAccount); // get account data
    this.positionData = _C(exchange.GetPosition); // get position data
    var recordsData = _C(exchange.GetRecords); //get k-line data
    exchange.SetContractType(tradeTypeA); // subscribe arbitrage contract A
    var depthDataA = _C(exchange.GetDepth); // deep data of arbitrage contract A
    exchange.SetContractType(tradeTypeB); // subscribe arbitrage contract B
    var depthDataB = _C(exchange.GetDepth); // deep data of arbitrage contract B
    this.time = recordsData[recordsData.length - 1].Time; // get the latest time data
    this.askA = depthDataA.Asks[0].Price; // the latest selling price of arbitrage contract A
    this.bidA = depthDataA.Bids[0].Price; // the latest buying price of arbitrage contract A
    this.askB = depthDataB.Asks[0].Price; // the latest selling price of arbitrage contract B
    this.bidB = depthDataB.Bids[0].Price; // the latest buying price of arbitrage contract B
    // Positive arbitrage spread(the latest selling price of contract A -the latest buying price of contract B )
    this.basb = depthDataA.Asks[0].Price - depthDataB.Bids[0].Price;
    // Reverse arbitrage spread(the latest buying price of contract A -the latest selling price of contract B )
    this.sabb = depthDataA.Bids[0].Price - depthDataB.Asks[0].Price;
}

// get position information
Data.prototype.mp = function (tradeType, type) {
    var positionData = this.positionData; // get position data
    for (var i = 0; i < positionData.length; i++) {
        if (positionData[i].ContractType == tradeType) {
            if (positionData[i].Type == type) {
                if (positionData[i].Amount > 0) {
                    return positionData[i].Amount;
                }
            }
        }
    }
    return false;
}

// Synthetize new K-line data and boll indicator data
Data.prototype.boll = function (num, timeCycle) {
    var self = {}; // Temporary object
    // the median of Positive arbitrage spread and reverse arbitrage spread
    self.Close = (this.basb + this.sabb) / 2;
    if (this.timeA == this.timeB) {
        self.Time = this.time;
    } // Comparing two depth data timestamps
    if (this.time - oldTime > timeCycle * 60000) {
        bars.push(self);
        oldTime = this.time;
    } // According to the specified time period, insert the spread data object in the K-line array.
    if (bars.length > num * 2) {
        bars.shift(); // Control K-line array length
    } else {
        return;
    }
    var boll = TA.BOLL(bars, num, 2); // Call the boll indicator in the Talib Library
    return {
        up: boll[0][boll[0].length - 1], // up rail of boll indicator
        middle: boll[1][boll[1].length - 1], // middle rail of boll indicator
        down: boll[2][boll[2].length - 1] // down rail of boll indicator
    } // Return a processed boll indicator data.
}

// place order
Data.prototype.trade = function (tradeType, type) {
    exchange.SetContractType(tradeType); // Resubscribe contract before placing order
    var askPrice, bidPrice;
    if (tradeType == tradeTypeA) { // if it's contract A
        askPrice = this.askA; // set askPrice
        bidPrice = this.bidA; // set bidPrice
    } else if (tradeType == tradeTypeB) { // if it's contract B
        askPrice = this.askB; // set askPrice
        bidPrice = this.bidB; // set bidPrice
    }
    switch (type) { // Match order mode
        case "buy":
            exchange.SetDirection(type); // Set order mode
            return exchange.Buy(askPrice, unit);
        case "sell":
            exchange.SetDirection(type); // Set order mode
            return exchange.Sell(bidPrice, unit);
        case "closebuy":
            exchange.SetDirection(type); // Set order mode
            return exchange.Sell(bidPrice, unit);
        case "closesell":
            exchange.SetDirection(type); // Set order mode
            return exchange.Buy(askPrice, unit);
        default:
            return false;
    }
}

// cancel order
Data.prototype.cancelOrders = function () {
    Sleep(500); // delay before canceling, because some exchanges you know...
    var orders = _C(exchange.GetOrders); // Get the array of pending orders
    if (orders.length > 0) { // if there is pending order
        for (var i = 0; i < orders.length; i++) { //check through the array of pending orders
            exchange.CancelOrder(orders[i].Id); //cancel pending orders one by one
            Sleep(500); //Delay 0.5 seconds
        }
        return false; // return false if pending orders have been cancelled
    }
    return true; //return true if there is no pending order
}

// handle holding single contract
Data.prototype.isEven = function () {
    var positionData = this.positionData; // get position data
    var type = null; // converse position direction 
    // If the length of the position array divided by some number and the remainder is 2, the result is not equal to 0 or the length of the position array is not equal to 2
    if (positionData.length % 2 != 0 || positionData.length != 2) {
        for (var i = 0; i < positionData.length; i++) { // check through the array of positions
            if (positionData[i].Type == 0) { // if it's long position
                type = 10; // Set order parameters
            } else if (positionData[i].Type == 1) { // if it's short position
                type = -10; // Set order parameters
            }
            // close all positions
            this.trade(positionData[i].ContractType, type, positionData[i].Amount);
        }
    }
}

// drawing chart
Data.prototype.drawingChart = function (boll) {
    var nowTime = new Date().getTime();
    ObjChart.add([0, [nowTime, boll.up]]);
    ObjChart.add([1, [nowTime, boll.middle]]);
    ObjChart.add([2, [nowTime, boll.down]]);
    ObjChart.add([3, [nowTime, this.basb]]);
    ObjChart.add([4, [nowTime, this.sabb]]);
    ObjChart.update(chart);
}

// trading condition
function onTick() {
    var data = new Data(tradeTypeA, tradeTypeB); // Create a base data object
    var accountStocks = data.accountData.Stocks; // account balance
    var boll = data.boll(dataLength, timeCycle); // get boll indicator data
    if (!boll) return; // return if there is no boll data
    // Spread description
    // basb = (the latest selling price of contract A - the latest buying price of contract B)
    // sabb = (the latest buying price of contract A - the latest selling price of contract B)
    if (data.sabb > boll.middle && data.sabb < boll.up) { // if sabb is higher than the middle rail
        if (data.mp(tradeTypeA, 0)) { // check if contract A has long positon before placing order
            data.trade(tradeTypeA, "closebuy"); // close long position of contract A
        }
        if (data.mp(tradeTypeB, 1)) { // check if contract B has short positon before placing order
            data.trade(tradeTypeB, "closesell"); // close short position of contract B
        }
    } else if (data.basb < boll.middle && data.basb > boll.down) { // if basb is lower than the middle rail
        if (data.mp(tradeTypeA, 1)) { // check if contract A has short positon before placing order
            data.trade(tradeTypeA, "closesell"); // close short position of contract A
        }
        if (data.mp(tradeTypeB, 0)) { // check if contract B has long positon before placing order
            data.trade(tradeTypeB, "closebuy"); // close long position of contract B
        }
    }
    if (accountStocks * Math.max(data.askA, data.askB) > 1) { // If there is balance in the account
        if (data.basb < boll.down) { // if basb spread is lower than the down rail
            if (!data.mp(tradeTypeA, 0)) { // check if contract A has long positon before placing order
                data.trade(tradeTypeA, "buy"); // open long position of contract A
            }
            if (!data.mp(tradeTypeB, 1)) { // check if contract B has short positon before placing order
                data.trade(tradeTypeB, "sell"); // open short position of contract B
            }
        } else if (data.sabb > boll.up) { // if sabb spread is higher than the up rail
            if (!data.mp(tradeTypeA, 1)) { // check if contract A has short positon before placing order
                data.trade(tradeTypeA, "sell"); // open short position of contract A
            }
            if (!data.mp(tradeTypeB, 0)) { // check if contract B has long positon before placing order
                data.trade(tradeTypeB, "buy"); // open long position of contract B
            }
        }
    }
    data.cancelOrders(); // cancel orders
    data.drawingChart(boll); // drawing chart
    data.isEven(); // process holding single contract
}

//enter function
function main() {
    // filter the information that is not very important in the console
    SetErrorFilter("429|GetRecords:|GetOrders:|GetDepth:|GetAccount|:Buy|Sell|timeout|Futures_OP");
    exchange.IO("currency", name + '_USDT'); //Set the cryptocurrency type to be traded
    ObjChart.reset(); //Empty the drawn charts before the program starts
    LogProfitReset(); //Empty the status bar information before the program starts
    while (true) { // Enter polling mode
        onTick(); // Execute onTick function
        Sleep(500); // sleep for o.5 seconds
    }
}