एफएमजेड एपीआई निर्देश

पिछले 10 लॉग में और बाकी साफ लॉग रीसेट करना (१०)
}

```Python
def main():
    LogReset(10)

void main() {
    LogReset(10);
}

लॉगवैक्यूम

LogVacuum(), को बुलाकरLogReset()लॉग को साफ करने के लिए कार्य, भंडारण स्थान कब्जा कर लिया द्वारा बरामदएसक्यूलाइटजब डेटा मिटाया जाता है. फ़ंक्शन कोई मूल्य नहीं लौटाता है. इसका कारण यह है किSQLiteडेटा हटाने पर कब्जा की जगह वापस नहीं लेता है, तो आप प्रदर्शन करने की जरूरत हैVACUUMतालिका को साफ करने के लिए, और अंतरिक्ष मुक्त करने के लिए. जब इस फ़ंक्शन को बुलाया जाता है, फ़ाइल स्थानांतरण ऑपरेशन एक बड़ी देरी के साथ होगा. यह एक उपयुक्त समय अंतराल पर इसे बुलाया करने की सिफारिश की है.

बाजार उद्धरण एपीआई

मुख्य बाजार इंटरफेस कार्यः

फ़ंक्शन का नाम	विवरण
GetTicker	टिक उद्धरण डेटा प्राप्त करें
GetRecords	के-लाइन डेटा प्राप्त करें
गहराई प्राप्त करें	ऑर्डर बुक डेटा प्राप्त करें (ऑर्डर गहराई डेटा)
GetTrades	बाजार में नवीनतम ट्रेडिंग रिकॉर्ड प्राप्त करें

निम्नलिखित कार्यों को कॉल किया जा सकता हैexchangeयाexchanges[0]वस्तुओं; उदाहरण के लिएः कार्यों, जैसेexchange.GetTicker();याexchanges[0].GetTicker();, वर्तमान ट्रेडिंग जोड़े और सेट अनुबंधों के बाजार उद्धरण लौटाता है।

नेटवर्क एक्सेस के साथ एपीआई फ़ंक्शंस को कॉल करने के लिए महत्वपूर्ण टिप्सःकिसी भी एपीआई फ़ंक्शन को कॉल करते समय जो प्लेटफ़ॉर्म इंटरफ़ेस (जैसेexchange.GetTicker(), exchange.Buy(Price, Amount), exchange.CancelOrder(Id), आदि), पहुँच की विफलता संभवतः विभिन्न कारणों से होती है। इसलिए हमें इन कार्यों के कॉल के लिए त्रुटि-सहिष्णु प्रसंस्करण करना चाहिए। उदाहरण के लिएःexchange.GetTicker()बाजार डेटा प्राप्त करने के लिए कार्य, प्लेटफॉर्म सर्वर समस्याओं और नेटवर्क प्रसारण समस्याओं आदि के कारण परिणाम हो सकता है कि रिटर्न मूल्यexchange.GetTicker()कार्य हैnull. फिर, के रिटर्न मूल्यexchange.GetTicker()दोष-सहिष्णु प्रसंस्करण द्वारा संभाला जाना चाहिए।

डेटा द्वारा लौटाया गयाexchange.GetTicker()निम्नलिखित कोड में फ़ंक्शनtickerचर, और हम का उपयोग करने से पहले गलती सहिष्णुता से निपटने की जरूरत हैticker variable.

function main() {
    var ticker = exchange.GetTicker()
    if(!ticker){
        // Recall once, or use other processing logic
        ticker = exchange.GetTicker()
    }
}

def main():
    ticker = exchange.GetTicker()
    if not ticker:
        ticker = exchange.GetTicker()

void main() {
    auto ticker = exchange.GetTicker();
    if(!ticker.Valid) {
        ticker = exchange.GetTicker();
        Log("Test");
    }
}

इसके अतिरिक्त, रणनीति के दोष-सहिष्णुता प्रदर्शन परीक्षण के लिए, एफएमजेड ने विशेष रूप से एक अद्वितीयदोष-सहिष्णु मोडबैकटेस्ट. बैकटेस्ट सिस्टम यादृच्छिक रूप से कुछ एपीआई कॉल वापस कर सकता है जो सेट पैरामीटर के अनुसार नेटवर्क तक पहुंचने पर होंगे, और कुछ असफल कॉल के रिटर्न मान वापस कर सकते हैं. आप जल्दी से बॉट में कार्यक्रम की मजबूती का परीक्षण कर सकते हैं. रणनीति संपादन पृष्ठ पर बैकटेस्ट प्रणाली पृष्ठ पर स्विच करें, क्लिक करेंउलटा त्रिभुजStart Backtest बटन के दाईं ओर ड्रॉप-डाउन कंट्रोल, और Backtest Fault Tolerant बटन पॉप अप होगा।

विनिमय.GetTicker()

exchange.GetTicker()वर्तमान ट्रेडिंग जोड़े और अनुबंधों के वर्तमान बाजार उद्धरण प्राप्त करता है, रिटर्न मूल्य के साथःTickerसंरचना। बैकटेस्ट प्रणाली में,Tickerद्वारा लौटाए गए डेटाexchange.GetTicker()कार्य, जहांHighऔरLowरोबोट में बिक्री 1 और बिक्री 1 के वर्तमान समय से लिए गए अनुकरणीय मूल्य हैं। वास्तविक चलने में क्रिप्टोक्यूरेंसी एक्सचेंज द्वारा परिभाषित एक निश्चित अवधि में उच्चतम मूल्य और सबसे कम मूल्य हैTick interface.

• Tickerसंरचना

function main(){
    var ticker = exchange.GetTicker()
    /*
        The platform interface may not be accessible due to network problems (even if the device's docker program can open the platform website, the API may not be accessible)
        At this time, ticker is null, when accessing ticker. When it is "High", it will cause an error; so when testing, ensure that you can access the platform interface
    */
    Log("High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Volume:", ticker.Volume)
}

def main():
    ticker = exchange.GetTicker()
    Log("High:", ticker["High"], "Low:", ticker["Low"], "Sell:", ticker["Sell"], "Buy:", ticker["Buy"], "Last:", ticker["Last"], "Volume:", ticker["Volume"])

void main() {
    auto ticker = exchange.GetTicker();
    Log("High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Volume:", ticker.Volume);
}

वास्तविक बॉट में (बैकटेस्ट नहीं),Infoके रिटर्न मान में विशेषताexchange.GetTicker()फ़ंक्शन इंटरफेस को बुलाए जाने पर लौटाए गए मूल डेटा को संग्रहीत करता है.

विनिमय.GetDepth()

exchange.GetDepth()वर्तमान व्यापारिक जोड़े और अनुबंधों के विनिमय आदेश पुस्तिका डेटा प्राप्त करता है। रिटर्न मानःDepth structure.

Depthसंरचना में संरचनाओं के दो सरणी होते हैं, अर्थात्Asks[]औरBids[], AsksऔरBidsनिम्नलिखित संरचना चर शामिल हैं:

डेटा प्रकार	चर का नाम	विवरण
संख्या	मूल्य	मूल्य
संख्या	राशि	राशि

• Depthसंरचना

उदाहरण के लिए, अगर मैं वर्तमान बिक्री दूसरे मूल्य प्राप्त करना चाहते हैं, मैं इस तरह कोड लिख सकते हैंः

function main(){
    var depth = exchange.GetDepth()
    /*
       The platform interface may not be accessible due to network reasons (even if the device's docker program can open the platform website, the API may not be accessible)
       At this time, depth is null. When accessing depth.Asks[1].Price, it will cause an error; so when testing, ensure that you can access the platform interface
    */
    var price = depth.Asks[1].Price
    Log("Sell 2 price is:", price)
}

def main():
    depth = exchange.GetDepth()
    price = depth["Asks"][1]["Price"]
    Log("Sell 2 price is:", price)

void main() {
    auto depth = exchange.GetDepth();
    auto price = depth.Asks[1].Price;
    Log("Sell 2 price is:", price);
}

विनिमय.GetTrades ((()

exchange.GetTrades()प्लेटफ़ॉर्म ट्रेडिंग इतिहास प्राप्त करता है (आपका अपना नहीं). रिटर्न मान:Tradeकुछ एक्सचेंजों का समर्थन नहीं करता है। विशिष्ट परिस्थितियों के अनुसार, रेंज के भीतर ट्रेडिंग रिकॉर्ड पर निर्भर करता है। लौटाए गए डेटा एक सरणी है, जहां प्रत्येक तत्व का समय अनुक्रम समान हैexchange.GetRecordsफ़ंक्शन, यानी, सरणी का अंतिम तत्व वर्तमान समय के निकटतम डेटा है।

• Tradeसंरचना

// In the simulated backtest, the data is empty; to have a trading history, there must be a real bot running
function main(){
    var trades = exchange.GetTrades()
    /*
        The platform interface may not be accessible due to network reasons (even if the device's docker program can open the platform website, the API may not be accessible)
        At this time, "trades" is null. When accessing trades[0].Id, it will cause an error; so when testing, ensure that you can access the platform interface
    */
    Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type)
}

def main():
    trades = exchange.GetTrades()
    Log("id:", trades[0]["Id"], "time:", trades[0]["Time"], "Price:", trades[0]["Price"], "Amount:", trades[0]["Amount"], "type:", trades[0]["Type"])

void main() {
    auto trades = exchange.GetTrades();
    Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type);
}

विनिमय.GetRecords()

exchange.GetRecords(Period)K-लाइन अवधि बोट बनाते समय निर्दिष्ट है; यदि आप पैरामीटर निर्दिष्ट करते हैं जबexchange.GetRecords()function बुलाया जाता है, प्राप्त डेटा पैरामीटर अवधि के अनुरूप K-लाइन डेटा होगा। यदि कोई निर्दिष्ट पैरामीटर नहीं है, तो K-लाइन डेटा बॉट पैरामीटर पर सेट K-लाइन अवधि या बैकटेस्ट पृष्ठ पर सेट K-लाइन अवधि के अनुसार लौटाया जाता है।

पैरामीटरPeriod:

• पीरियड_एम1: 1 मिनट को संदर्भित करता है
• पीरियड_एम5: 5 मिनट का संदर्भ देता है
• पीरियड_एम15: 15 मिनट का संदर्भ देता है
• पीरियड_एम30: 30 मिनट को संदर्भित करता है
• पीरियड_एच1: 1 घंटे से संबंधित है
• पीरियड_डी1: 1 दिन को संदर्भित करता है के पैरामीटर मूल्यPeriodकेवल उपर्युक्त परिभाषित मानक काल को ही पार कर सकता है, बल्कि सेकंड की इकाई में संख्याओं को भी पार कर सकता है।

का रिटर्न मानexchange.GetRecords(Period)कार्य: रिटर्न मान के एक सरणी हैRecordसंरचनाओं, लौटाए गए K-लाइन डेटा समय के साथ जमा हो जाएगा, संचित K-लाइन सलाखों की ऊपरी सीमाexchange.SetMaxBarLenफ़ंक्शन सेटिंग. डिफ़ॉल्ट ऊपरी सीमा 5000 के-लाइन बार है जब यह सेट नहीं है. जब के-लाइन डेटा के-लाइन बार संचय सीमा तक पहुंचता है, तो इसे के-लाइन बार जोड़कर और सबसे पहले के-लाइन बार (जैसे कतार में / बाहर) को हटाकर अपडेट किया जाएगा। कुछ एक्सचेंजों में के-लाइन इंटरफ़ेस प्रदान नहीं किया जाता है, फिर डॉकर के-लाइन उत्पन्न करने के लिए वास्तविक समय में बाजार लेनदेन रिकॉर्ड डेटा एकत्र करता है।

के-लाइन सलाखों की संख्याGetRecordsफ़ंक्शन शुरू में कहा जाता है.

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

के लिएexchange.GetRecords(Period)कार्य, बॉट और बैकटेस्टक्रिप्टोक्यूरेंसीदोनों कस्टम अवधि का समर्थन, और पैरामीटरPeriodसेकंड की संख्या है। उदाहरण के लिएः

function main() {
    // Print K-line data with a K-line period of 120 seconds (2 minutes)
    Log(exchange.GetRecords(60 * 2))         
    // Print K-line data with a K-line period of 5 minutes
    Log(exchange.GetRecords(PERIOD_M5))      
}

def main():
    Log(exchange.GetRecords(60 * 2))
    Log(exchange.GetRecords(PERIOD_M5))

void main() {
    Log(exchange.GetRecords(60 * 2)[0]);
    Log(exchange.GetRecords(PERIOD_M5)[0]);
}

सेटिंगPeriodपैरामीटर 5 के लिए 5 सेकंड की अवधि के साथ K-लाइन डेटा का अनुरोध करना है। यदिPeriodपैरामीटर 60 से समान रूप से विभाजित नहीं है (यानी प्रतिनिधित्व अवधि अनुपलब्ध मिनटों की अवधि है), प्रणाली की निचली परत के प्रासंगिक इंटरफ़ेस का उपयोग करता हैGetTradesट्रेडिंग रिकॉर्ड डेटा प्राप्त करने और आवश्यक K-लाइन डेटा को संश्लेषित करने के लिए। यदिPeriodपैरामीटर समान रूप से 60 से विभाजित है, तो आवश्यक K-लाइन डेटा कम से कम 1 मिनट के K-लाइन डेटा का उपयोग करके संश्लेषित किया जाता है (यदि संभव हो तो आवश्यक K-लाइन डेटा को संश्लेषित करने के लिए एक बड़ी अवधि का उपयोग करके) ।

• Recordसंरचना

function main(){
    var records = exchange.GetRecords(PERIOD_H1)
    /*
        The platform interface may not be accessible due to network reasons (even if the device's docker program can open the platform website, the API may not be accessible)
        At this time, "records" is null. When accessing records[0].Time, it will cause an error; so when testing, ensure that you can access the platform interface
    */
    Log("The first k-line data is, Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High)
    Log("The second k-line data is, Time:", records[1].Time ,"Close:", records[1].Close)
    Log("Current K-line (latest)", records[records.length-1], "Current K-line (latest)", records[records.length-2])
}

def main():
    records = exchange.GetRecords(PERIOD_H1)
    Log("The first k-line data is, Time:", records[0]["Time"], "Open:", records[0]["Open"], "High:", records[0]["High"])
    Log("The second k-line data is, Time:", records[1]["Time"], "Close:", records[1]["Close"])
    Log("Current K-line (latest)", records[-1], "Current K-line (latest)", records[-2])

void main() {
    auto records = exchange.GetRecords(PERIOD_H1);
    Log("The first k-line data is, Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High);
    Log("The second k-line data is, Time:", records[1].Time, "Close:", records[1].Close);
    Log("Current K-line (latest)", records[records.size() - 1], "Current K-line (latest)", records[records.size() - 2]);
}

exchange.GetRecords()के-लाइन डेटा प्राप्त करने के लिए दो शर्तें हैंः

• एक्सचेंज एक के-लाइन डेटा इंटरफेस प्रदान करता है। इस मामले में, प्राप्त डेटा एक्सचेंज द्वारा सीधे लौटाए गए डेटा हैं।

• एक्सचेंज एक के-लाइन डेटा इंटरफ़ेस प्रदान नहीं करता है। एफएमजेड डॉकर कार्यक्रम हर बार रणनीति कार्यक्रम कॉल करता है जब एक्सचेंज के नवीनतम व्यापार रिकॉर्ड प्राप्त करता हैexchange.GetRecords(), यानी, यह कहता है किexchange.GetTrades()डेटा प्राप्त करने और के-लाइन डेटा को संश्लेषित करने के लिए कार्य।

सिस्टम में सिमुलेशन स्तर के बैकटेस्ट कोअंतर्निहित के-लाइन अवधि(जब बैकटेस्टिंग प्रणाली बैकटेस्टिंग के स्तर का अनुकरण करती है, तो सेट के अनुसार टिक डेटा उत्पन्न करने के लिए संबंधित के-लाइन डेटा का उपयोग किया जाता हैअंतर्निहित के-लाइन अवधि); यह ध्यान दिया जाना चाहिए कि रणनीति में प्राप्त K-लाइन डेटा की अवधि कम नहीं हो सकती हैअंतर्निहित के-लाइन अवधिक्योंकि सिमुलेशन स्तर के बैकटेस्ट में, प्रत्येक अवधि के के-लाइन डेटा को बैकटेस्ट प्रणाली में अंतर्निहित के-लाइन अवधि के अनुरूप के-लाइन डेटा द्वारा संश्लेषित किया जाता है।

अंदरcppभाषा, यदि आप अपने स्वयं के के-लाइन डेटा का निर्माण करने की जरूरत है, वहाँ निम्नलिखित कोड उदाहरण हैंः

#include <sstream>
void main() { 
    Records r;
    r.Valid = true;
    for (auto i = 0; i < 10; i++) {
        Record ele;
        ele.Time = i * 100000;
        ele.High = i * 10000;
        ele.Low = i * 1000;
        ele.Close = i * 100;
        ele.Open = i * 10;
        ele.Volume = i * 1;
        r.push_back(ele);
    }
    // Output display: Records[10]
    Log(r);                      
    auto ma = TA.MA(r,10);       
    // Output display: [nan,nan,nan,nan,nan,nan,nan,nan,nan,450]
    Log(ma);                     
}

विनिमय.GetPeriod (()

..exchange.GetPeriod()फ़ंक्शन में रणनीतियों को चलाने पर FMZ प्लेटफॉर्म वेबसाइट पृष्ठ पर सेट K-लाइन अवधि लौटाता हैबैकटेस्टऔरबॉट. रिटर्न मान सेकंड की इकाई में एक पूर्णांक है. रिटर्न मानः संख्यात्मक प्रकार.

function main() {
    // For example, in the backtest and bot, set the K-line period on the website page of FMZ platform to 1 hour
    var period = exchange.GetPeriod()
    Log("K-line period:", period / (60 * 60), "hour")
}

def main():
    period = exchange.GetPeriod()
    Log("K-line period:", period / (60 * 60), "hour")

void main() {
    auto period = exchange.GetPeriod();
    Log("K-line period:", period / (60 * 60.0), "hour");
}

विनिमय.SetMaxBarLen(Len)

..exchange.SetMaxBarLen(Len)क्रिप्टोक्यूरेंसी रणनीति के रनटाइम के दौरान कार्य दो पहलुओं को प्रभावित करता हैः

• पहली बार प्राप्त की गई के-लाइन बार (BAR) की संख्या को प्रभावित करता है।
• K-लाइन बार (BAR) की ऊपरी सीमा को प्रभावित करना।

function main() {
    exchange.SetMaxBarLen(50)
    var records = exchange.GetRecords()
    Log(records.length, records)
}

def main():
    exchange.SetMaxBarLen(50)
    r = exchange.GetRecords()
    Log(len(r), r)

void main() {
    exchange.SetMaxBarLen(50);
    auto r = exchange.GetRecords();
    Log(r.size(), r[0]);
}

विनिमय.GetRawJSON()

exchange.GetRawJSON()अंतिम द्वारा लौटाई गई कच्ची सामग्री (स्ट्रिंग) लौटाता हैRESTrequest, जिसका उपयोग स्वयं द्वारा डेटा को पार्स करने के लिए किया जा सकता है. रिटर्न मानः स्ट्रिंग प्रकार, केवल क्रिप्टोक्यूरेंसी लाइव ट्रेडिंग वातावरण में मान्य है. बैकटेस्ट फ़ंक्शन का समर्थन नहीं करता है. में रणनीतियाँcppभाषा इस कार्य का समर्थन नहीं करती है।

function main(){
    exchange.GetAccount(); 
    var obj = JSON.parse(exchange.GetRawJSON());
    Log(obj);
}

import json
def main():
    exchange.GetAccount()
    obj = json.loads(exchange.GetRawJSON())
    Log(obj)

void main() {
    auto obj = exchange.GetAccount();
    // C++ doe not support "GetRawJSON" function
    Log(obj);
}

विनिमय.GetRate()

exchange.GetRate()वर्तमान में विनिमय में प्रयुक्त मुद्रा और वर्तमान में प्रदर्शित मूल्य निर्धारण मुद्रा की विनिमय दरें लौटाता है, और 1 का लौटाया गया मान इंगित करता है कि विनिमय दर रूपांतरण अक्षम है। लौटाया गया मानः संख्यात्मक प्रकार।

नोटः

• यदिexchange.SetRate()विनिमय दर निर्धारित करने के लिए नहीं कहा गया है, विनिमय दर मूल्य द्वारा लौटायाexchange.GetRate()डिफ़ॉल्ट रूप से 1 है, अर्थात वर्तमान में प्रदर्शित विनिमय दर रूपांतरण का आदान-प्रदान नहीं किया गया है।
• यदिexchange.SetRate()विनिमय दर मूल्य निर्धारित करने के लिए प्रयोग किया गया है, जैसे,exchange.SetRate(7), तब ट्रेडिंग प्लेटफॉर्म की प्रचलित मुद्रा का प्रतिनिधित्व करने वाले वर्तमान विनिमय वस्तु की सभी मूल्य जानकारी, जैसे कि उद्धरण, गहराई, आदेश मूल्य आदि, रूपांतरण के लिए पूर्व निर्धारित विनिमय दर 7 से गुणा की जाएगी।
• यदिexchangeमूल्य निर्धारण मुद्रा के रूप में अमरीकी डालर के साथ विनिमय के अनुरूप है, कॉल के बादexchange.SetRate(7), बॉट की सभी कीमतों को 7 से गुणा करके सीएनवाई के करीब की कीमतों में परिवर्तित किया जाएगा।exchange.GetRate()7 है।

विनिमय.GetUSDCNY()

exchange.GetUSDCNY()अमेरिकी डॉलर की नवीनतम विनिमय दर (डेटा स्रोत द्वारा प्रदान किया गया) देता हैyahoo) लौटाया गया मान: संख्यात्मक प्रकार।

exchange.SetData ((कुंजी, मान)

..exchange.SetData(Key, Value)इस फ़ंक्शन का उपयोग उस समय लोड किए गए डेटा को सेट करने के लिए किया जाता है जब रणनीति चल रही है, जो कोई भी आर्थिक संकेतक, उद्योग डेटा, प्रासंगिक सूचकांक आदि हो सकता है। इसका उपयोग ट्रेडिंग रणनीतियों के लिए सभी मात्रात्मक जानकारी को मापने के लिए किया जा सकता है और बैकटेस्ट सिस्टम में उपयोग करने का समर्थन भी कर सकता है।

कॉल करने की विधिexchange.SetData(Key, Value)कार्य:

• डेटा को सीधे रणनीति में लिखें डेटा प्रारूप आवश्यक है क्योंकिdataनिम्नलिखित उदाहरण में चर।

  /*backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */
  function main() {
      var data = [
          [1579536000000, "abc"],
          [1579622400000, 123],
          [1579708800000, {"price": 123}],
          [1579795200000, ["abc", 123, {"price": 123}]]
      ]
      exchange.SetData("test", data)
      while(true) {
          Log(exchange.GetData("test"))
          Sleep(1000)
      }
  }
  

  '''backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  '''  
  
  def main():
      data = [
          [1579536000000, "abc"],
          [1579622400000, 123],
          [1579708800000, {"price": 123}],
          [1579795200000, ["abc", 123, {"price": 123}]]
      ]
      exchange.SetData("test", data)
      while True:
          Log(exchange.GetData("test"))
          Sleep(1000)
  

  /*backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */  
  
  void main() {
      json data = R"([
          [1579536000000, "abc"],
          [1579622400000, 123],
          [1579708800000, {"price": 123}],
          [1579795200000, ["abc", 123, {"price": 123}]]
      ])"_json;
      
      exchange.SetData("test", data);
      while(true) {
          Log(exchange.GetData("test"));
          Sleep(1000);
      }
  }
  

  जब उपरोक्त परीक्षण कोड चलाया जाता है, तो संबंधित डेटा संबंधित समय पर प्राप्त किया जाएगा, जैसा कि चित्र में दिखाया गया हैः

  

  जैसा कि हम देख सकते हैं, समय के मुहर के अनुरूप समय1579622400000है2020-01-22 00: 00: 00; जब रणनीति कार्यक्रम इस समय के बाद चलता है, अगले डेटा टाइमस्टैम्प से पहले1579708800000, यानी, समय से पहले2020-01-23 00: 00: 00, कॉल करेंexchange.GetData(Source)डेटा प्राप्त करने के लिए समारोह. सभी प्राप्त सामग्री है[1579622400000, 123]. के रूप में कार्यक्रम चलाने के लिए जारी है और समय बदल जाता है, डेटा टुकड़ा टुकड़ा डेटा इस तरह प्राप्त.

• बाहरी लिंक के माध्यम से डेटा का अनुरोध करें

  अनुरोधित डेटा प्रारूप

  {
      "schema":["time","data"],
      "data":[
          [1579536000000, "abc"],
          [1579622400000, 123],
          [1579708800000, {"price": 123}],
          [1579795200000, ["abc", 123, {"price": 123}]]
      ]
  }
  

  कहाँschemaलोड किए गए डेटा के मुख्य भाग में प्रत्येक रिकॉर्ड का डेटा प्रारूप है, प्रारूप इस प्रकार तय किया गया है["time", "data"], जो किdataडेटा का एक-एक करके विशेषता प्रारूप।dataविशेषता डेटा के मुख्य शरीर को संग्रहीत करती है, और डेटा का प्रत्येक टुकड़ा मिलीसेकंड स्तर के टाइमस्टैम्प और डेटा सामग्री से बना होता है (डेटा सामग्री कोई भी JSON एन्कोडेड डेटा हो सकती है) ।

  परीक्षण के लिए सेवा कार्यक्रम में लिखा हैGoभाषाः

  package main
  import (
      "fmt"
      "net/http"
      "encoding/json"
  )  
  
  func Handle (w http.ResponseWriter, r *http.Request) {
      defer func() {
          fmt.Println("req:", *r)
          ret := map[string]interface{}{
              "schema": []string{"time","data"},
              "data": []interface{}{
                  []interface{}{1579536000000, "abc"},
                  []interface{}{1579622400000, 123},
                  []interface{}{1579708800000, map[string]interface{}{"price":123}},
                  []interface{}{1579795200000, []interface{}{"abc", 123, map[string]interface{}{"price":123}}},
              },
          }
          b, _ := json.Marshal(ret)
          w.Write(b)
      }()
  }  
  
  func main () {
      fmt.Println("listen http://localhost:9090")
      http.HandleFunc("/data", Handle)
      http.ListenAndServe(":9090", nil)
  }
  

  अनुरोध प्राप्त करने के बाद, कार्यक्रम डेटा का जवाब देता हैः

  {
      "schema":["time","data"],
      "data":[
          [1579536000000, "abc"],
          [1579622400000, 123],
          [1579708800000, {"price": 123}],
          [1579795200000, ["abc", 123, {"price": 123}]]
      ]
  }
  

  परीक्षण रणनीति कोडः

  /*backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */
  function main() {
      while(true) {
          Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
          Sleep(1000)
      }
  }
  

  '''backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  '''  
  
  def main():
      while True:
          Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
          Sleep(1000)
  

  /*backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */  
  
  void main() {
      while(true) {
          Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
          Sleep(1000);
      }
  }
  

exchange.GetData ((स्रोत)

..exchange.GetData(Source)फ़ंक्शन का उपयोग डेटा को लोड करने के लिए किया जाता हैexchange.SetData(Key, Value)बाह्य लिंक द्वारा प्रदान किए गए फ़ंक्शन या डेटा का उपयोग बैकटेस्ट सिस्टम में किया जा सकता है। बैकटेस्ट के दौरान एक बार डेटा प्राप्त किया जाता है, और वास्तविक ट्रेडिंग के दौरान एक मिनट के लिए डेटा कैश किया जाता है।

• सीधे लिखे गए डेटा की कॉल विधि प्राप्त करना

  /*backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */
  function main() {
      exchange.SetData("test", [[1579536000000, _D(1579536000000)], [1579622400000, _D(1579622400000)], [1579708800000, _D(1579708800000)]])
      while(true) {
          Log(exchange.GetData("test"))
          Sleep(1000 * 60 * 60 * 24)
      }
  }
  

  '''backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  '''  
  def main():
      exchange.SetData("test", [[1579536000000, _D(1579536000000/1000)], [1579622400000, _D(1579622400000/1000)], [1579708800000, _D(1579708800000/1000)]])
      while True:
          Log(exchange.GetData("test"))
          Sleep(1000 * 60 * 60 * 24)
  

  /*backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */    
  void main() {
      json arr = R"([[1579536000000, ""], [1579622400000, ""], [1579708800000, ""]])"_json;
      arr[0][1] = _D(1579536000000);
      arr[1][1] = _D(1579622400000);
      arr[2][1] = _D(1579708800000);
      exchange.SetData("test", arr);
      while(true) {
          Log(exchange.GetData("test"));
          Sleep(1000 * 60 * 60 * 24);
      }
  }
  

• बाह्य लिंक से डेटा को बुलाने की विधि

  function main() {
      Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
      Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
  }
  

  def main():
      Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
      Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
  

  void main() {
      Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
      Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"));
  }
  

• प्लेटफार्म डेटा केंद्र के मौलिक डेटा का उपयोग करें उपयोग करेंexchange.GetData(Source)प्राप्त करने के लिए कार्यमौलिक आंकड़े.

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

ट्रेडिंग एपीआई

निम्नलिखित कार्यों को कॉल किया जा सकता है के माध्यम सेexchangeयाexchanges[0]वस्तु। उदाहरण के लिएःexchange.Sell(100, 1);इंगित करता है कि अगला ऑर्डर एक्सचेंज पर 100 की कीमत और 1 की मात्रा वाला एक बिक्री ऑर्डर है।

विनिमय.खरीदें ((मूल्य, राशि)

exchange.Buy(Price, Amount)एक खरीद आदेश रखने और एक आदेश आईडी वापस करने के लिए प्रयोग किया जाता है। पैरामीटर मानःPriceआदेश मूल्य संख्या के प्रकार में है, औरAmountऑर्डर राशि संख्या के प्रकार में है। रिटर्न मानः स्ट्रिंग प्रकार या संख्यात्मक प्रकार (विशिष्ट प्रकार प्रत्येक एक्सचेंज प्लेटफॉर्म के रिटर्न प्रकार पर निर्भर करता है) ।

लौटाए गए ऑर्डर नंबर का उपयोग ऑर्डर की जानकारी की क्वेरी करने और ऑर्डर रद्द करने के लिए किया जा सकता है।

function main() {
    var id = exchange.Buy(100, 1);
    Log("id:", id);
}

def main():
    id = exchange.Buy(100, 1)
    Log("id:", id)

void main() {
    auto id = exchange.Buy(100, 1);
    Log("id:", id);
}

• वायदा आदेश

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

  // The following is the wrong call
  function main() {
      exchange.SetContractType("quarter")
    
      // Set short direction
      exchange.SetDirection("sell")     
      // Place a buy order, and you will get an error, so you can only sell short
      var id = exchange.Buy(50, 1)      
  
      // Set short direction
      exchange.SetDirection("buy")      
      // Place a sell order, and you will get an error, so you can only buy long
      var id2 = exchange.Sell(60, 1)    
    
      // Set close long position direction
      exchange.SetDirection("closebuy")    
      // Place a buy order, and you will get an error, so you can only sell short
      var id3 = exchange.Buy(-1, 1)        
    
      // Set close short position direction
      exchange.SetDirection("closesell")   
      // Place a sell order, and you will get an error, so you can only buy long
      var id4 = exchange.Sell(-1, 1)       
  }
  

  # The following is the wrong call
  def main():
      exchange.SetContractType("quarter")
      exchange.SetDirection("sell")
      id = exchange.Buy(50, 1)
      exchange.SetDirection("buy")
      id2 = exchange.Sell(60, 1)
      exchange.SetDirection("closebuy")
      id3 = exchange.Buy(-1, 1)
      exchange.SetDirection("closesell")
      id4 = exchange.Sell(-1, 1)
  

  // The following is the wrong call
  void main() {
      exchange.SetContractType("quarter");
      exchange.SetDirection("sell");
      auto id = exchange.Buy(50, 1);
      exchange.SetDirection("buy");
      auto id2 = exchange.Sell(60, 1);
      exchange.SetDirection("closebuy");
      auto id3 = exchange.Buy(-1, 1);
      exchange.SetDirection("closesell");
      auto id4 = exchange.Sell(-1, 1);
  }
  

  त्रुटि संदेशः

  direction is sell, invalid order type Buy
  direction is buy, invalid order type Sell
  direction is closebuy, invalid order type Buy
  direction is closesell, invalid order type Sell
  

• बाजार व्यवस्था

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

  // For example, trading pairs: ETH_BTC, bought in by market order
  function main() {
      // Buy a market order, and buy ETH coins equal to 0.1 BTC (quote currency) 
      exchange.Buy(-1, 0.1)    
  }
  

  def main():
      exchange.Buy(-1, 0.1)
  

  void main() {
      exchange.Buy(-1, 0.1);
  }
  

विनिमय.बिक्री ((मूल्य, राशि)

exchange.Sell(Price, Amount)एक बिक्री आदेश देता है और एक आदेश आईडी लौटाता है। पैरामीटर मानःPriceऑर्डर की कीमत, संख्यात्मक प्रकार है।Amountआदेश राशि, संख्यात्मक प्रकार है। रिटर्न मानः स्ट्रिंग प्रकार या संख्यात्मक प्रकार (विशिष्ट प्रकार प्रत्येक एक्सचेंज के रिटर्न प्रकार पर निर्भर करता है) ।

लौटाया गया आदेश संख्या, जिसका उपयोग आदेश की जानकारी पूछने और आदेश रद्द करने के लिए किया जा सकता है।

function main(){
    var id = exchange.Sell(100, 1)
    Log("id:", id)
}

def main():
    id = exchange.Sell(100, 1)
    Log("id:", id)

void main() {
    auto id = exchange.Sell(100, 1);
    Log("id:", id);
}

• वायदा आदेश

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

• बाजार आदेश

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

  // For example, trading pairs: ETH_BTC, sold out by market order 
  function main() {
      // Note: Sell by a market order, and sell 0.2 ETH coins 
      exchange.Sell(-1, 0.2)   
  }
  

  def main():
      exchange.Sell(-1, 0.2)
  

  void main() {
      exchange.Sell(-1, 0.2);
  }
  

विनिमय.ऑर्डर रद्द करें (आईडी)

exchange.CancelOrder(orderId), इस फ़ंक्शन का उद्देश्य आईडी के साथ एक आदेश को रद्द करना है। पैरामीटर मानःIdक्रम संख्या है, स्ट्रिंग प्रकार या संख्यात्मक प्रकार में (विशिष्ट प्रकार प्रत्येक मंच पर आदेश देने पर रिटर्न प्रकार पर निर्भर करता है); रिटर्न मानः bool प्रकार।

ऑपरेशन परिणाम लौटाता है;trueइसका अर्थ है कि आदेश रद्द करने का अनुरोध सफलतापूर्वक भेजा गया है;falseका मतलब है कि रद्द आदेश अनुरोध भेजने में विफल रहता है (वापसी मूल्य केवल इंगित करता है कि भेजने के अनुरोध सफल है या नहीं, इसलिए यह कॉल करने के लिए सबसे अच्छा हैexchange.GetOrders()यह जांचने के लिए कि क्या प्लेटफ़ॉर्म ऑर्डर को रद्द करता है) ।

function main(){
    var id = exchange.Sell(99999, 1)
    exchange.CancelOrder(id)
}

def main():
    id = exchange.Sell(99999, 1)
    exchange.CancelOrder(id)

void main() {
    auto id = exchange.Sell(99999, 1);
    exchange.CancelOrder(id);
}

एफएमजेड का एपीआई फ़ंक्शन, जो लॉग आउटपुट फ़ंक्शन उत्पन्न कर सकता है, जैसेLog(...), exchange.Buy(Price, Amount)औरexchange.CancelOrder(Id). आप कुछ अतिरिक्त आउटपुट मापदंडों के साथ आवश्यक मापदंडों का पालन कर सकते हैं, जैसेexchange.CancelOrder(orders[j].Id, orders[j])इस तरह, यह रद्द कर रहा हैorders[j]आदेश है कि इस आदेश की जानकारी के आउटपुट के साथ है, अर्थात्Orderसंरचनाorders[j].

function main() {
    Log("data1", "data2", "data3", "...")
    var data2 = 200
    var id = exchange.Sell(100000, 0.1, "Incidental data1", data2, "...")
    exchange.CancelOrder(id, "Incidental data1", data2, "...")
    LogProfit(100, "Incidental data1", data2, "...")
}

def main():
    Log("data1", "data2", "data3", "...")
    data2 = 200
    id = exchange.Sell(100000, 0.1, "Incidental data1", data2, "...")
    exchange.CancelOrder(id, "Incidental data1", data2, "...")
    LogProfit(100, "Incidental data1", data2, "...")

void main() {
    Log("data1", "data2", "data3", "...");
    int data2 = 200;
    auto id = exchange.Sell(100000, 0.1, "Incidental data1", data2, "...");
    exchange.CancelOrder(id, "Incidental data1", data2, "...");
    LogProfit(100, "Incidental data1", data2, "...");
}

विनिमय.GetOrder ((Id)

exchange.GetOrder(orderId)क्रम संख्या के अनुसार आदेश विवरण प्राप्त करता है। पैरामीटर मानःIdप्राप्त करने के लिए क्रम संख्या है, औरIdस्ट्रिंग या संख्यात्मक प्रकार का है (विशिष्ट प्रकार प्रत्येक एक्सचेंज के रिटर्न प्रकार पर निर्भर करता है) । रिटर्न मानःOrderसंरचना। (कुछ एक्सचेंजों द्वारा समर्थित नहीं)

• Orderसंरचना
• AvgPriceऔसत निष्पादित मूल्य दर्शाता है (कुछ एक्सचेंजों में यह फ़ील्ड समर्थित नहीं है; यदि वे समर्थित नहीं हैं तो इसे 0 पर सेट करें) ।

function main(){
    var id = exchange.Sell(1000, 1)
    // The parameter id is the order number, you need to fill in the number of the order you want to query
    var order = exchange.GetOrder(id)      
    Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:",
        order.DealAmount, "Status:", order.Status, "Type:", order.Type)
}

def main():
    id = exchange.Sell(1000, 1)
    order = exchange.GetOrder(id)
    Log("Id:", order["Id"], "Price:", order["Price"], "Amount:", order["Amount"], "DealAmount:", 
        order["DealAmount"], "Status:", order["Status"], "Type:", order["Type"])

void main() {
    auto id = exchange.Sell(1000, 1);
    auto order = exchange.GetOrder(id);
    Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:", 
        order.DealAmount, "Status:", order.Status, "Type:", order.Type);
}

विनिमय.GetOrders ((()

exchange.GetOrders()सभी अधूरे आदेश प्राप्त करता है। रिटर्न मानःOrderसंरचना सरणी। के लिएOrderसंरचना, कृपया देखेंexchange.GetOrder()जब विनिमय वस्तु द्वारा दर्शाया गया खाताexchangeकोई लंबित आदेश नहीं है, कॉल करेंexchange.GetOrders()एक खाली सरणी वापस करने के लिए, अर्थात्ः[].

function main(){
    exchange.Sell(1000, 1)
    exchange.Sell(1000, 1)
    var orders = exchange.GetOrders()
    Log("Information for unfinished order 1, ID:", orders[0].Id, "Price:", orders[0].Price, "Amount:", orders[0].Amount,
        "DealAmount:", orders[0].DealAmount, "type:", orders[0].Type)
    Log("Information for unfinished order 2, ID:", orders[1].Id, "Price:", orders[1].Price, "Amount:", orders[1].Amount,
        "DealAmount:", orders[1].DealAmount, "type:", orders[1].Type)
}

def main():
    exchange.Sell(1000, 1)
    exchange.Sell(1000, 1)
    orders = exchange.GetOrders()
    Log("Information for unfinished order 1, ID:", orders[0]["Id"], "Price:", orders[0]["Price"], "Amount:", orders[0]["Amount"], 
        "DealAmount:", orders[0]["DealAmount"], "type:", orders[0]["Type"])
    Log("Information for unfinished order 2, ID:", orders[1]["Id"], "Price:", orders[1]["Price"], "Amount:", orders[1]["Amount"],
        "DealAmount:", orders[1]["DealAmount"], "type:", orders[1]["Type"])

void main() {
    exchange.Sell(1000, 1);
    exchange.Sell(1000, 1);
    auto orders = exchange.GetOrders();
    Log("Information for unfinished order 1, ID:", orders[0].Id, "Price:", orders[0].Price, "Amount:", orders[0].Amount, 
        "DealAmount:", orders[0].DealAmount, "type:", orders[0].Type);
    Log("Information for unfinished order 2, ID:", orders[1].Id, "Price:", orders[1].Price, "Amount:", orders[1].Amount,
        "DealAmount:", orders[1].DealAmount, "type:", orders[1].Type);
}

..exchange.GetOrders()फ़ंक्शन वर्तमान में सेट की अधूरी आदेश जानकारी प्राप्त करता हैव्यापारिक जोड़ीयह ध्यान दिया जाना चाहिए कि क्रिप्टोक्यूरेंसी वायदा में न केवल व्यापारिक जोड़े बल्कि अनुबंध कोड के बीच भी अंतर हैं।

// Test OKX contract tradings, to know whether "GetOrders" gets all unfinished contract orders
function main(){
    // The next weekly buy order; the price of the order minus 50 guarantees no execution; pending orders
    exchange.SetContractType("this_week")
    exchange.SetDirection("buy")
    var ticker = exchange.GetTicker()
    Log(ticker)
    exchange.Buy(ticker.Last - 50, 1)

    // The next quarterly sell order; the price plus 50 guarantees that it will not be executed, and the pending order has been switched to a quarterly contract
    exchange.SetContractType("quarter")
    exchange.SetDirection("sell")
    ticker = exchange.GetTicker()
    Log(ticker)
    exchange.Sell(ticker.Last + 50, 1)

    // Get the unfinished orders
    Log("orders", exchange.GetOrders())
}

def main():
    exchange.SetContractType("this_week")
    exchange.SetDirection("buy")
    ticker = exchange.GetTicker()
    Log(ticker)
    exchange.Buy(ticker["Last"] - 50, 1)

    exchange.SetContractType("quarter")
    exchange.SetDirection("sell")
    ticker = exchange.GetTicker()
    Log(ticker)
    exchange.Sell(ticker["Last"] + 50, 1)

    Log("orders", exchange.GetOrders())

void main() {
    exchange.SetContractType("this_week");
    exchange.SetDirection("buy");
    auto ticker = exchange.GetTicker();
    Log(ticker);
    exchange.Buy(ticker.Last - 50, 1);

    exchange.SetContractType("quarter");
    exchange.SetDirection("sell");
    ticker = exchange.GetTicker();
    Log(ticker);
    exchange.Sell(ticker.Last + 50, 1);

    Log("orders", exchange.GetOrders());
}

प्राप्त अधूरे आदेश की जानकारीः

[{"Id":17116430886,"Amount":1,"Price":808.4,"DealAmount":0,"AvgPrice":0,"Status":0,"Type":1,"ContractType":"quarter"}]

यह देखा जा सकता है कि क्रिप्टोक्यूरेंसी व्यापार में, आदेश प्राप्त द्वाराexchange.GetOrders()केवल वर्तमान में निर्धारित अनुबंध के अधूरे आदेश हैं।

विनिमय.सेट सटीकता ((...)

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

function main(){
    // Set the decimal precision of the price to 2 digits, and set the precision of the quantity of the symbol order to 3 digits
    exchange.SetPrecision(2, 3)
}    

def main():
    exchange.SetPrecision(2, 3)

void main() {
    exchange.SetPrecision(2, 3);
}

exchange.SetRate ((Rate)

exchange.SetRate(Rate)विनिमय में प्रचलन मुद्रा की विनिमय दर निर्धारित करता है। पैरामीटर मानःRateहैnumberप्रकार. रिटर्न मान:number type.

function main(){
    Log(exchange.GetTicker())
    // Set the exchange rate conversion
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    // Set to 1, without conversion
    exchange.SetRate(1)
}

def main():
    Log(exchange.GetTicker())
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    exchange.SetRate(1)

void main() {
    Log(exchange.GetTicker());
    exchange.SetRate(7);
    Log(exchange.GetTicker());
    exchange.SetRate(1);
}

नोटः

• यदि आपने विनिमय दर का मान सेट किया हैexchange.SetRate(Rate), जैसे कि 7, तो, सभी मूल्य जानकारी, वर्तमान बाजार मूल्य, गहराई, और आदेश मूल्य सहित, वर्तमान मुद्रा द्वारा दर्शाए गए परिसंचरण मुद्रा केexchangeवस्तुओं को रूपांतरण के लिए निर्धारित विनिमय दर 7 से गुणा किया जाएगा।

• उदाहरण के लिए,exchangeएक विनिमय दर है जो अमेरिकी डॉलर में है।exchange.SetRate(7)कहा जाता है, तो वास्तविक व्यापार की सभी कीमतों को 7 से गुणा किया जाएगा और CNY के करीब कीमतों में परिवर्तित किया जाएगा।

exchange.IO(…)

exchange.IO("api", httpMethod, resource, params, raw), एक्सचेंज के अन्य कार्यात्मक इंटरफेस को कॉल करें। पैरामीटर मानःhttpMehodस्ट्रिंग प्रकार का है; यह अनुरोध प्रकार भरता है, जैसे किPOSTयाGET. resourceस्ट्रिंग प्रकार का है, यह अनुरोध पथ में भरता है.paramsस्ट्रिंग प्रकार का है, यह अनुरोध मापदंडों में भरता है.rawमूल JSON स्ट्रिंग पैरामीटर है और इसे छोड़ दिया जा सकता है.exchange.IO("api", httpMethod, resource, params, raw)फ़ंक्शन कॉल एक्सचेंज इंटरफेस का उपयोग करेगा। जब कोई त्रुटि होती है और कॉल विफल हो जाती है, तो यह एक शून्य मान (नेटवर्क अनुरोध के साथ फ़ंक्शन, जैसे किGetTicker()औरGetAccount(), आदि, कॉल विफल होने पर शून्य मान लौटाता है) केवल लाइव ट्रेडिंग कॉल करने का समर्थन करता हैexchange.IO("api", ...) function.

ओकेएक्स बैच आदेश के उदाहरण के लिए, पैरामीटर का उपयोग करेंrawआदेश मापदंडों को पारित करने के लिएः

function main() {
    var arrOrders = [
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
    ]
    
    // Call exchange.IO to directly access the platform batch ordering interface
    var ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", JSON.stringify(arrOrders))
    Log(ret)
}

import json
def main():
    arrOrders = [
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}, 
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
    ]
    ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", json.dumps(arrOrders))
    Log(ret)

void main() {
    json arrOrders = R"([
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
    ])"_json;
    auto ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", arrOrders.dump());
    Log(ret);
}

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

नोटः यदि कुंजी मानparamsपैरामीटर (यानी, HTTP अनुरोध पैरामीटर) एक स्ट्रिंग है, यह एकल उद्धरण के साथ लिपटे की जरूरत है (प्रतीक') पैरामीटर मान के दोनों ओर। उदाहरण के लिए:bitfinex exchange.

var amount = 1
var price = 10
var basecurrency = "ltc"
function main () {
    // Notice that amount.toString() and price.toString() both have a ' character on the left and right
    var message = "symbol=" + basecurrency + "&amount='" + amount.toString() + "'&price='" + price.toString() + "'&side=buy" + "&type=limit"
    var id = exchange.IO("api", "POST", "/v1/order/new", message)
}

amount = 1
price = 10
basecurrency = "ltc"
def main():
    message = "symbol=" + basecurrency + "&amount='" + str(amount) + "'&price='" + str(price) + "'&side=buy" + "&type=limit"
    id = exchange.IO("api", "POST", "/v1/order/new", message)

void main() {
    auto amount = 1.0;
    auto price = 10.0;
    auto basecurrency = "ltc";
    string message = format("symbol=%s&amount=\"%.1f\"&price=\"%.1f\"&side=buy&type=limit", basecurrency, amount, price);
    auto id = exchange.IO("api", "POST", "/v1/order/new", message);
}

पहुँच का उदाहरणOKXइंटरफेसः

function main(){
    var ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
    Log(ret)
}

def main():
    ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
    Log(ret)

void main() {
    auto ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT");
    Log(ret);
}

परीक्षण के दौरान लौटाए गए डेटाः

{"code":"0","data":[],"msg":""}

अन्य सेटिंग्सexchange.IOकार्य:

• वर्तमान विनिमय के व्यापारिक जोड़े बदलें

  exchange.IO("currency", "ETH_BTC")

  function main() {
      // For example, set the current trading pair of the exchange object on the bot to BTC_USDT, and print the current trading pair market
      Log(exchange.GetTicker())
      // Switch trading pair to LTC_BTC      
      exchange.IO("currency", "LTC_BTC")
      Log(exchange.GetTicker())
  }
  

  def main():
      Log(exchange.GetTicker())
      exchange.IO("currency", "LTC_BTC")
      Log(exchange.GetTicker())
  

  void main() {
      Log(exchange.GetTicker());
      exchange.IO("currency", "LTC_BTC");
      Log(exchange.GetTicker());
  }
  

  इस प्रकार,व्यापारिक जोड़ेविन्यस्तजब बॉट जोड़ा जाता हैयाबैकटेस्ट चलाया गया हैकोड के माध्यम से स्विच किया जाएगा.

  नोटः

  • 1. बैकटेस्ट सिस्टम अब ट्रेडिंग जोड़े (केवल क्रिप्टोक्यूरेंसी के स्पॉट एक्सचेंज ऑब्जेक्ट्स) को स्विच करने का समर्थन करता है। बैकटेस्ट के दौरान, यह ध्यान दिया जाना चाहिए कि एक ही बोली मुद्रा के केवल ट्रेडिंग जोड़े को स्विच किया जा सकता है। उदाहरण के लिए, वर्तमान ट्रेडिंग जोड़ी हैETH_BTC, जो केवल स्विच किया जा सकता हैLTC_BTC, नहींLTC_USDT.
  • 2. यदिwebsocketप्रोटोकॉल मोड Huobi स्पॉट विनिमय वस्तुओं पर स्विच है, आप उपयोग नहीं कर सकतेexchange.IO("currency", "XXX_YYY")मुद्राओं को बदलने के लिए।
  • 3. क्रिप्टोक्यूरेंसी वायदा एक्सचेंजों के लिए, यदि ट्रेडिंग जोड़े स्विच किए जाते हैं, तो आपको यह निर्धारित करने के लिए अनुबंध को फिर से सेट करने की आवश्यकता होती है कि आप किस अनुबंध के साथ व्यापार करना चाहते हैं।
  • 4. आप नए का भी उपयोग कर सकते हैंexchange.SetCurrency(Symbol)व्यापारिक जोड़े बदलने के लिए कार्य, और उपयोगexchange.IO("currency","XXX_YYY")संगतता बनाए रखने की विधि।

• exchange.IOफ़ंक्शन एक्सचेंज एपीआई आधार पते (RESET अनुबंध; कुछ एक्सचेंजों का समर्थन नहीं करता है) स्विच करें. अब उपयोगexchange.SetBase(Base)फ़ंक्शन को एक्सचेंज एपीआई आधार पते को स्विच करने के लिए समर्थित किया गया है, और उपयोगexchange.IO("base","https://xxx.xxx.xxx")संगतता बनाए रखने की विधि।

  उदाहरण के लिएः जब विनिमय वस्तु को कैप्सूल किया जाता है, तो डिफ़ॉल्ट आधार पता हैhttps://api.huobipro.com, के लिए स्विच करने के लिएःhttps://api.huobi.pro, निम्नलिखित कोड का प्रयोग करें।

  function main () {
      // exchanges[0] is the first exchange object added when the bot is added 
      exchanges[0].IO("base", "https://api.huobi.pro")        
  }
  

  def main():
      exchanges[0].IO("base", "https://api.huobi.pro")
  

  void main() {
      exchanges[0].IO("base", "https://api.huobi.pro");
  }
  

  आधार पते को वापस बदलेंःhttps://api.huobipro.com.

  function main () {
      exchanges[0].IO("base", "https://api.huobipro.com")
  }
  

  def main():
      exchanges[0].IO("base", "https://api.huobipro.com")
  

अधिक