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

पीपी खाली मुख्य (() { विनिमय[0].IO(आधार, https://api.huobipro.com”); }

The ZB exchange is special. There are two addresses: one is the market data interface address, and the other is the trading interface address. Switch the address:
```js
function main() {
    // The second parameter of exchange.IO is the trading interface address, and the third parameter is the market interface address, which is switched to an address that can be accessed domestically
    exchange.IO("base", "https://trade.zb.plus", "http://api.zb.plus")    
    // Print the account information
    Log(exchange.GetAccount())                                            
}

def main():
    exchange.IO("base", "https://trade.zb.plus", "http://api.zb.plus")
    Log(exchange.GetAccount())

void main() {
    exchange.IO("base", "https://trade.zb.plus", "http://api.zb.plus");
    Log(exchange.GetAccount());
}

• बाजार मोड बदलें वर्तमान में समर्थित एक्सचेंजोंः

  विनिमय	टिप्पणी
  हुओबी स्पॉट	वेबसॉकेट प्रोटोकॉल का समर्थन करने के बाद, कोडexchange.IO(मुद्रा, ETH) का उपयोग मुद्राओं को बदलने के लिए नहीं किया जा सकता

  • exchange.IO("websocket")

    बाजार संचार प्रोटोकॉल कोwebsocket(डिफ़ॉल्ट है आराम), बाजार उद्धरण प्राप्त करने का तरीका स्विच के बाद बदल जाएगा।exchange.GetTicker()औरexchange.GetDepth()पर स्विच किया जाएगाwebsocketप्रोटोकॉल को अद्यतन करने के लिए, बाजार डेटा के कच्चे सक्रिय अधिग्रहण से बाजार डेटा के निष्क्रिय अधिग्रहण के लिए, केवल Huobi एक्सचेंज वर्तमान में समर्थित है।

  जब बाजार मोड पुश तंत्र है, तो आप सेट करने के लिए निम्न फ़ंक्शन को कॉल कर सकते हैंः

  • exchange.IO("mode", 0)तत्काल रिटर्न मोड. यदि वर्तमान बाजार डेटा पुश को एक्सचेंज से प्राप्त नहीं किया गया है, तो पुराने बाजार डेटा को तुरंत वापस कर दिया जाएगा. यदि नए डेटा हैं, तो नए डेटा को वापस कर दिया जाएगा.

  • exchange.IO("mode", 1)कैश मोड (डिफ़ॉल्ट मोड). यदि एक्सचेंज के नवीनतम बाजार डेटा प्राप्त नहीं किए गए हैं (पिछले इंटरफ़ेस से प्राप्त डेटा की तुलना में), प्राप्त करने के लिए प्रतीक्षा करें और फिर वापस आएं। यदि इस फ़ंक्शन को कॉल करने से पहले नवीनतम बाजार डेटा प्राप्त किया गया है, तो नवीनतम डेटा तुरंत वापस आ जाएगा।

  • exchange.IO("mode", 2)जबरन अद्यतन मोड. दर्ज करें और प्रतीक्षा करें जब तक अगले नवीनतम पुश डेटा एक्सचेंज प्राप्त किया जाता है और फिर वापस आ जाते हैं.

  यदि आप पहली बार नवीनतम बाजार जानकारी प्राप्त करना चाहते हैं, तो आप स्विच कर सकते हैंwebsocketऔर न पुकारोSleepकार्य, और तुरंत डेटा का परीक्षण करें।exchange.GetTicker()औरexchange.GetDepth()कार्य कैश मोड में काम करते हैं, जैसेः

  function main () {
      exchange.IO("websocket")
      while (true) {
          Log(exchange.GetTicker())
      }
  }
  

  def main():
      exchange.IO("websocket")
      while True:
          Log(exchange.GetTicker())
  

  void main() {
      exchange.IO("websocket");
      while(true) {
          Log(exchange.GetTicker());
      }
  }
  

• एक्सचेंज लीवरेज खाता मोड

  प्रयोगexchange.IO("trade_margin")लीवरेज खाते के मोड पर स्विच करने के लिए, ऑर्डर देने और खाता परिसंपत्तियों तक पहुंचने के लिए एक्सचेंज के लीवरेज इंटरफेस का उपयोग किया जाएगा। प्रयोगexchange.IO("trade_normal")सामान्य खाता मोड पर वापस स्विच करने के लिए।

  समर्थित आदान-प्रदानः

  विनिमय	विशेष टिप्पणी
  ओकेएक्स	लाभप्रदता खाता मोड के व्यापारिक जोड़े सामान्य से भिन्न होते हैं, और कुछ व्यापारिक जोड़े उपलब्ध नहीं हो सकते हैं।exchange.IO("cross", true)लीवरेज्ड खाते की पूर्ण स्थिति पर स्विच करना औरexchange.IO("cross", false)अलग स्थिति में स्विच करने के लिए।
  हुओबी	लीवरेज खाता मोड के ट्रेडिंग जोड़े सामान्य लोगों से अलग होते हैं, और कुछ ट्रेडिंग जोड़े उपलब्ध नहीं हो सकते हैं। Huobi लीवरेज खाता क्रॉसिंग स्थिति और अलग स्थिति में विभाजित है। उपयोगtrade_marginलीवरेज खाते में अलग-थलग स्थिति पर स्विच करने के लिए;trade_super_marginलीवरेज खाते पर क्रॉस की गई स्थिति पर स्विच करने के लिए;trade_normalसामान्य मुद्रा मोड पर स्विच करने के लिए
  ZB	धन को केवल QC में स्थानांतरित किया जा सकता है। लीवरेज ट्रेडिंग क्षेत्र में, विभिन्न ट्रेडिंग जोड़े के बीच धन स्वतंत्र हैं, अर्थात ETH_QC ट्रेडिंग जोड़ी के तहत QC सिक्कों की संख्या BTC_QC में दिखाई नहीं देती है
  बाइनेंस	लीवरेज खातों को क्रॉस पोजीशन और आइसोलेट पोजीशन में विभाजित किया गया है।trade_marginअलग स्थिति में स्विच करने के लिए; उपयोगtrade_super_marginक्रॉसिंग पोजीशन में स्विच करने के लिए; उपयोगtrade_normalसामान्य मुद्रा मोड पर स्विच करने के लिए
  द्वार	लीवरेज खातों को क्रॉस पोजीशन और आइसोलेट पोजीशन में विभाजित किया गया है।trade_marginअलग स्थिति में स्विच करने के लिए; उपयोगtrade_super_marginक्रॉसिंग पोजीशन में स्विच करने के लिए; उपयोगtrade_normalसामान्य मुद्रा मोड पर स्विच करने के लिए
  AscendEx	प्रयोगexchange.IO("trade_margin")लीवरेज खाता मोड पर स्विच करने और उपयोग करने के लिएexchange.IO("trade_normal")सामान्य खाता मोड पर वापस स्विच करने के लिए।

विनिमय.लॉग ((...)

exchange.Log(LogType, Price, Amount)जब बुलाया जाता है तो कोई ऑर्डर नहीं देता है और यह केवल एक्सचेंज लॉग की जानकारी आउटपुट करने के लिए ट्रेडिंग जानकारी रिकॉर्ड करता है।

नोटः

• यह फलन के सदस्य फलन हैexchangeवस्तुओं, जो वैश्विक समारोह से अलग हैLog().
• पैरामीटर मानःLogTypeले सकता हैLOG_TYPE_BUY, LOG_TYPE_SELL, LOG_TYPE_CANCELऔरPriceकीमत के रूप में, औरAmountमात्रा के रूप में।LogTypeहैLOG_TYPE_CANCEL, Priceपैरामीटर आदेश आईडी है।

प्रयोगexchange.Log(LogType, Price, Amount)लाइव ट्रेडिंग अनुवर्ती परीक्षण, अनुकरणीय ऑर्डर प्लेसमेंट करने और ऑर्डर रिकॉर्ड करने में सहायता करने के लिए।

सबसे आम उपयोग का मामला हैःexchange.IOविनिमय के सशर्त आदेश बनाने के इंटरफेस का उपयोग करने के लिए सशर्त आदेश रखने के लिए।exchange.IOफ़ंक्शन बॉट लॉग रिकॉर्डिंग में विनिमय लॉग जानकारी आउटपुट नहीं करेगा. इस प्रकार आप उपयोग कर सकते हैंexchange.Log(LogType, Price, Amount)लॉग आउटपुट को पूरक करने के लिए ताकि प्लेसिंग ऑर्डर की जानकारी दर्ज की जा सके।

var id = 123
function main() {
    // Order type: buy; price: 999; quantity: 0.1
    exchange.Log(LOG_TYPE_BUY, 999, 0.1)      
    // Cancel the order
    exchange.Log(LOG_TYPE_CANCEL, id)         
}

id = 123
def main():
    exchange.Log(LOG_TYPE_BUY, 999, 0.1)
    exchange.Log(LOG_TYPE_CANCEL, id)

void main() {
    auto id = 123;
    exchange.Log(LOG_TYPE_BUY, 999, 0.1);
    exchange.Log(LOG_TYPE_CANCEL, id);
}

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

exchange.HMAC(Algo, OutputAlgo, Data, Key)समर्थन करता हैएचएमएसीकी एन्क्रिप्शन गणनाएमडी5/sha256/sha512/श1, और केवल लाइव ट्रेडिंग चल रहा है समर्थित है।

exchange.HMAC("sha256", "hex", "xxxxx", "{{secretkey}}")उद्धृत करने के लिएaccessKey, उपयोग"{{accesskey}}". उद्धृत करने के लिएsecretKey, उपयोग"{{secretkey}}"; या आप सादे पाठ का उपयोग कर सकते हैं"abc-123-xxxx". "{{accessKey}}","{{secretkey}}"केवल तभी मान्य होता है जब इस फ़ंक्शन का प्रयोग किया जाता है.OutputAlgoसमर्थनः हेक्स, बेस64।विशिष्ट उदाहरण

बिटमेक्स स्थिति परिवर्तन (wss प्रोटोकॉल) को पुश करें

function main() {
    var APIKEY = "your Access Key(Bitmex API ID)"
    var expires = parseInt(Date.now() / 1000) + 10
    var signature = exchange.HMAC("sha256", "hex", "GET/realtime" + expires, "{{secretkey}}")
    var client = Dial("wss://www.bitmex.com/realtime", 60)
    var auth = JSON.stringify({args: [APIKEY, expires, signature], op: "authKeyExpires"})
    var pos = 0
    client.write(auth)
    client.write('{"op": "subscribe", "args": "position"}')
    while (true) {
        bitmexData = client.read()
        if(bitmexData.table == 'position' && pos != parseInt(bitmexData.data[0].currentQty)){
            Log('position change', pos, parseInt(bitmexData.data[0].currentQty), '@')
            pos = parseInt(bitmexData.data[0].currentQty)
        }
    }
}

import time
def main():
    APIKEY = "your Access Key(Bitmex API ID)"
    expires = int(time.time() + 10)
    signature = exchange.HMAC("sha256", "hex", "GET/realtime" + str(expires), "{{secretkey}}")
    client = Dial("wss://www.bitmex.com/realtime", 60)
    auth = json.dumps({"args": [APIKEY, expires, signature], "op": "authKeyExpires"})
    pos = 0
    client.write(auth)
    client.write('{"op": "subscribe", "args": "position"}')
    while True:
        bitmexData = json.loads(client.read())
        if "table" in bitmexData and bitmexData["table"] == "position" and len(bitmexData["data"]) != 0 and pos != bitmexData["data"][0]["currentQty"]:   
            Log("position change", pos, bitmexData["data"][0]["currentQty"], "@")
            pos = bitmexData["data"][0]["currentQty"]

void main() {
    auto APIKEY = "your Access Key(Bitmex API ID)";
    auto expires = Unix() + 10;
    auto signature = exchange.HMAC("sha256", "hex", format("GET/realtime%d", expires), "{{secretkey}}");
    
    auto client = Dial("wss://www.bitmex.com/realtime", 60);
    json auth = R"({"args": [], "op": "authKeyExpires"})"_json;

    auth["args"].push_back(APIKEY);
    auth["args"].push_back(expires);
    auth["args"].push_back(signature);
    auto pos = 0;
    client.write(auth.dump());
    client.write("{\"op\": \"subscribe\", \"args\": \"position\"}");
    while(true) {
        auto bitmexData = json::parse(client.read());
        if(bitmexData["table"] == "position" && bitmexData["data"][0].find("currentQty") != bitmexData["data"][0].end() && pos != bitmexData["data"][0]["currentQty"]) {
            Log("Test");
            Log("position change", pos, bitmexData["data"][0]["currentQty"], "@");
            pos = bitmexData["data"][0]["currentQty"];
        }
    }
}

आदान-प्रदान. जाओ.

exchange.Go(Method, Args...)बहु-थ्रेडेड असिंक्रोनस समर्थित फ़ंक्शन है, जो सभी समर्थित फ़ंक्शनों के संचालन को असिंक्रोनस समवर्ती में बदल सकता है (जो केवल क्रिप्टोक्यूरेंसी एक्सचेंजों का समर्थन करता है) । पैरामीटर मान:Method, स्ट्रिंग प्रकार का, अर्थात् फ़ंक्शन नाम एक साथ बुलाया.

नोटः

• यह फ़ंक्शन केवल लाइव ट्रेडिंग में चलाने पर मल्टी-थ्रेडेड निष्पादन कार्य बनाता है। बैकटेस्ट मल्टी-थ्रेडेड समवर्ती निष्पादन कार्यों का समर्थन नहीं करता है (बैकटेस्ट उपलब्ध है, लेकिन यह अभी भी क्रमिक रूप से निष्पादित होता है) ।
• के बादexchange.Goफ़ंक्शन एक वस्तु देता है,waitफ़ंक्शन को ऑब्जेक्ट के माध्यम से थ्रेड द्वारा लौटाए गए डेटा को पुनर्प्राप्त करने के लिए बुलाया जाता है।waitपूरा हो गया है. यदि समय सीमा पैरामीटर निर्दिष्टwait, थ्रेड को टाइमआउट होने पर भी रिलीज़ नहीं किया जाएगा; इस तरह, थ्रेड को केवल थ्रेड परिणाम प्राप्त करके ही स्वचालित रूप से रिलीज़ किया जाएगा (चाहे समवर्ती रूप से एक्सेस किए गए इंटरफ़ेस को सफलतापूर्वक या असफल रूप से बुलाया गया हो) ।
• सरल शब्दों में कहें तो, चाहे लागू धागा सफल हो या ना हो, परिणाम कोwaitसमारोह, और धागा संसाधन द्वारा लागू कियाexchange.Goकार्य स्वचालित रूप से डॉकर द्वारा जारी किया जाता है।
• यदि रिटर्न परिणामwaitकार्य अंत में प्राप्त नहीं किया जाता है, धागा संसाधन स्वचालित रूप से जारी नहीं किया जाएगा, जो लागू धागे के संचय का कारण होगा; यदि धागे की संख्या 2000 से अधिक है, तो एक त्रुटि की सूचना दी जाएगीः"too many routine wait, max is 2000".

समर्थित कार्यःGetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositionऔरIO.

function main(){
    // The following four operations are executed concurrently and asynchronously by multiple threads, without time-consuming, but with immediate return.
    var a = exchange.Go("GetTicker")
    var b = exchange.Go("GetDepth") 
    var c = exchange.Go("Buy", 1000, 0.1)
    var d = exchange.Go("GetRecords", PERIOD_H1)
           
    // Call the "wait" method, to wait for the return of the asynchronously obtained "ticker" result 
    var ticker = a.wait()            
    // Return the depth; it is possible to return null, if the acquisition fails 
    var depth = b.wait()             
    // Return the order number; limit the timeout in 1 second; the timeout returns "undefined"; this object can continue to call "wait" to wait if the last "wait" is timeout 
    var orderId = c.wait(1000)
    if(typeof(orderId) == "undefined") {
        // Timeout, reacquire
        orderId = c.wait()
    }
    var records = d.wait()
}

def main():
    a = exchange.Go("GetTicker")
    b = exchange.Go("GetDepth")
    c = exchange.Go("Buy", 1000, 0.1)
    d = exchange.Go("GetRecords", PERIOD_H1)

    ticker, ok = a.wait()
    depth, ok = b.wait()
    orderId, ok = c.wait(1000)
    if ok == False:
        orderId, ok = c.wait()
    records, ok = d.wait()

void main() {
    auto a = exchange.Go("GetTicker");
    auto b = exchange.Go("GetDepth");
    auto c = exchange.Go("Buy", 1000, 0.1);
    auto d = exchange.Go("GetRecords", PERIOD_H1);

    Ticker ticker;
    Depth depth;
    Records records;
    TId orderId;
    a.wait(ticker);
    b.wait(depth);
    if(!c.wait(orderId, 300)) {
        c.wait(orderId);
    }
    d.wait(records);
}

नोटः

• न्याय करनाundefined, उपयोगtypeof(xx)==="undefined", क्योंकिnull == undefinedजावास्क्रिप्ट में उपलब्ध है।

function main() {
    var d = exchange.Go("GetRecords", PERIOD_H1)
    // Wait for K-line result
    var records = d.wait()
    // Here we wait for an asynchronous operation that has been waited and ended; it will return null, and record the error
    var ret = d.wait()
}

def main():
    d = exchange.Go("GetRecords", PERIOD_H1)
    records, ok = d.wait()
    ret, ok = d.wait()

void main() {
    auto d = exchange.Go("GetRecords", PERIOD_H1);
    Records records;
    d.wait(records);
    Records ret;
    d.wait(ret);
}

के बीच अंतरPythonऔरJavaScriptक्या यहPythonहैwaitफ़ंक्शन दो पैरामीटर लौटाता हैः पहला असिंक्रोनस एपीआई द्वारा लौटाया गया परिणाम है; दूसरा इंगित करता है कि असिंक्रोनस कॉल पूरा हो गया है या नहीं।

Pythonउदाहरण:

def main():
    d = exchange.Go("GetRecords", PERIOD_D1)
    # "ok" must return "True", unless the strategy is stopped
    ret, ok = d.wait()          
    # If the waiting times out, or "wait" for an ended instance, "ok" returns "False"
    ret, ok = d.wait(100)       
    ret, ok = d.wait(100)       

एक साथ कई एक्सचेंजों के उद्धरण प्राप्त करेंः

function main() {
    while(true) {
        var beginTS = new Date().getTime()
        var arrRoutine = []
        var arrTicker = []
        var arrName = []
        for(var i = 0; i < exchanges.length; i++) {
            arrRoutine.push(exchanges[i].Go("GetTicker"))
            arrName.push(exchanges[i].GetName())
        }

        for(var i = 0; i < arrRoutine.length; i++) {
            arrTicker.push(arrRoutine[i].wait())
        }
        var endTS = new Date().getTime()

        var tbl = {
            type: "table", 
            title: "Market Quotes", 
            cols: ["Index", "Name", "Latest Executed Price"], 
            rows: []
        }
        
        for(var i = 0; i < arrTicker.length; i++) {
            tbl.rows.push([i, arrName[i], arrTicker[i].Last])
        }

        LogStatus(_D(), "The total time to acquire multiple platforms concurrently is:", endTS - beginTS, "millisecond", "\n", "`" + JSON.stringify(tbl) + "`")
        Sleep(500)
    }
}

import time 
import json
def main():
    while True:
        beginTS = time.time()
        arrRoutine = []
        arrTicker = []
        arrName = []
        for i in range(len(exchanges)):
            arrRoutine.append(exchanges[i].Go("GetTicker"))
            arrName.append(exchanges[i].GetName())

        for i in range(len(exchanges)):
            ticker, ok = arrRoutine[i].wait()
            arrTicker.append(ticker)

        endTS = time.time()
        tbl = {
            "type": "table", 
            "title": "Market Quote", 
            "cols": ["Index", "Name", "Latest Executed Price"], 
            "rows": [] 
        }

        for i in range(len(arrTicker)):
            tbl["rows"].append([i, arrName[i], arrTicker[i]["Last"]])

        LogStatus(_D(), "The total time to acquire multiple platforms concurrently is:", endTS - beginTS, "second", "\n", "`" + json.dumps(tbl) + "`")
        Sleep(500)

void main() {
    while(true) {
        int length = exchanges.size();
        auto beginTS = UnixNano() / 1000000;
        Ticker arrTicker[length] = {};
        string arrName[length] = {};
        
        // Note that to add a few exchange objects, here we need to execute the "exchanges[n].Go" function several times. In this example, we need to add four exchange objects, which can be modified in details
        auto r0 = exchanges[0].Go("GetTicker");
        auto r1 = exchanges[1].Go("GetTicker");
        auto r2 = exchanges[2].Go("GetTicker");
        auto r3 = exchanges[3].Go("GetTicker");
        GoObj *arrRoutine[length] = {&r0, &r1, &r2, &r3};
        
        for(int i = 0; i < length; i++) {
            arrName[i] = exchanges[i].GetName();
        }

        for(int i = 0; i < length; i++) {
            Ticker ticker;
            arrRoutine[i]->wait(ticker);
            arrTicker[i] = ticker;
        }        
        auto endTS = UnixNano() / 1000000;

        json tbl = R"({
            "type": "table", 
            "title": "Market Quote", 
            "cols": ["Index", "Name", "Latest Executed Price"], 
            "rows": [] 
        })"_json;

        for(int i = 0; i < length; i++) {
            json arr = R"(["", "", ""])"_json;
            arr[0] = format("%d", i);
            arr[1] = arrName[i];
            arr[2] = format("%f", arrTicker[i].Last);
            tbl["rows"].push_back(arr);
        }

        LogStatus(_D(), "The total time to acquire multiple platforms concurrently is:", format("%d", endTS - beginTS), "millisecond", "\n", "`" + tbl.dump() + "`");
        Sleep(500);
    }
}

समवर्ती आमंत्रणexchange.IO("api", ...)कार्य:

function main() {
    /*  
       Use the OKX placing order interface to test
        POST /api/v5/trade/order        
    */
    
    var beginTS = new Date().getTime()
    var param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
    var ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
    var ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
    var ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
    
    var id1 = ret1.wait()
    var id2 = ret2.wait()
    var id3 = ret3.wait()
    var endTS = new Date().getTime()    

    Log("id1:", id1)
    Log("id2:", id2)
    Log("id3:", id3)
    Log("Time for placing orders concurrently:", endTS - beginTS, "millisecond")
}

import time
import json
def main():
    beginTS = time.time()
    param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
    ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
    ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
    ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))

    id1, ok1 = ret1.wait()
    id2, ok2 = ret2.wait()
    id3, ok3 = ret3.wait()
    endTS = time.time()

    Log("id1:", id1)
    Log("id2:", id2)
    Log("id3:", id3)
    Log("Time for placing orders concurrently:", endTS - beginTS, "second")

void main() {
    auto beginTS = UnixNano() / 1000000;
    json param = R"({"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"})"_json;
    auto ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
    auto ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
    auto ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());

    json id1 = R"({})"_json;
    json id2 = R"({})"_json;
    json id3 = R"({})"_json;

    ret1.wait(id1);
    ret2.wait(id2);
    ret3.wait(id3);
    auto endTS = UnixNano() / 1000000;

    Log("id1:", id1);
    Log("id2:", id2);
    Log("id3:", id3);
    Log("Time for placing orders concurrently:", endTS - beginTS, "millisecond");
}

खाता जानकारी

विनिमय.GetAccount()

exchange.GetAccount()विनिमय खाते की जानकारी लौटाता है। लौटाता मानःAccount structure.

• Accountसंरचना

function main(){
    var account = exchange.GetAccount()
    Log("Account information, Balance:", account.Balance, "FrozenBalance:", account.FrozenBalance, "Stocks:",
        account.Stocks, "FrozenStocks:", account.FrozenStocks)
}

def main():
    account = exchange.GetAccount()
    Log("Account information, Balance", account["Balance"], "FrozenBalance:", account["FrozenBalance"], "Stocks:", 
        account["Stocks"], "FrozenStocks:", account["FrozenStocks"])

void main() {
    auto account = exchange.GetAccount();
    Log("Account information, Balance", account.Balance, "FrozenBalance:", account.FrozenBalance, "Stocks:", 
        account.Stocks, "FrozenStocks:", account.FrozenStocks);
}

यदि विनिमय वस्तु एक क्रिप्टोक्यूरेंसी वायदा विनिमय पर सेट है और एक अनुबंध के साथ स्विचUSDTमार्जिन के रूप में (संदर्भ में देखेंexchange.SetContractTypeकैसे स्विच करने के लिए पता करने के लिए कार्य), परिसंपत्तियों लेUSDTमार्जिन के रूप में, जो विशेषता में दर्ज किया जाता हैBalanceऔरFrozenBalance.

function main(){
    // Switch the trading pair
    exchange.IO("currency", "BTC_USDT")     
    // Take OKX futures as an example; set the contract as the contract of the week, and the current trading pair is BTC_USDT, so the current contract is BTC USDT-margined contract of this week
    exchange.SetContractType("this_week")   
    // Acquire the data of the current account assets
    var account = exchange.GetAccount()
    // The available balance of USDT as margin
    Log(account.Balance)
    // The frozen amount of USDT as margin
    Log(account.FrozenBalance)
}

def main():
    exchange.IO("currency", "BTC_USDT")
    exchange.SetContractType("this_week")    
    account = exchange.GetAccount()
    Log(account["Balance"])
    Log(account["FrozenBalance"])

void main() {
    exchange.IO("currency", "BTC_USDT");
    exchange.SetContractType("this_week");    
    auto account = exchange.GetAccount();
    Log(account.Balance);
    Log(account.FrozenBalance);
}

exchange.GetName ((()

exchange.GetName()एक्सचेंज का नाम लौटाता है. लौटाता है मानः स्ट्रिंग प्रकार. आम तौर पर यह निर्धारित करने के लिए प्रयोग किया जाता हैexchangeयाexchanges[n]रणनीति कोड में वस्तुओं.

function main() {
    Log("Determine the exchange object to be OKX:", exchange.GetName() == "OKEX")
}

def main():
    Log("Determine the exchange object to be OKX:", exchange.GetName() == "OKEX")

void main() {
    Log("Determine the exchange object to be OKX:", exchange.GetName() == "OKEX");
}

डॉकर के लाइन संस्करण के आदेश के लिए, आप उपयोग कर सकते हैं-1विनिमय नामों की सूची मुद्रित करने के लिए आदेश.

विनिमय.GetLabel()

exchange.GetLabel()एक्सचेंज का कस्टम लेबल लौटाता है। लौटाता है मानः स्ट्रिंग प्रकार.

..exchangeयाexchanges[n]रणनीति कोड में वस्तुओं को आम तौर पर विनिमय वस्तुओं को कॉन्फ़िगर करते समय सेट किए गए लेबल द्वारा निर्धारित किया जाता है।

विनिमय.GetCurrency()

exchange.GetCurrency()एक्सचेंज द्वारा संचालित मुद्रा जोड़ी का नाम लौटाता है, और क्रिप्टोक्यूरेंसी प्लेटफ़ॉर्म एक स्ट्रिंग लौटाता है, जैसे किLTC_BTC. रिटर्न मानः स्ट्रिंग प्रकार.

विनिमय.सेट करेंसी(...)

..exchange.SetCurrency(Symbol)विनिमय वस्तु की वर्तमान व्यापार जोड़ी को स्विच करने के लिए उपयोग किया जाता है।exchange.IO ("currency","BTC_USDT")यह बैकटेस्टिंग प्रणाली में ट्रेडिंग जोड़े स्विच करने का समर्थन करता है, और ट्रेडिंग जोड़े का नामpricing currencyबैकटेस्टिंग प्रणाली में ट्रेडिंग जोड़े स्विच करते समय नहीं बदला जा सकता है (उदाहरण के लिए,BTC_USDTपर स्विच किया जा सकता हैLTC_USDT, लेकिन इसे स्विच नहीं किया जा सकता हैLTC_BTC) एक व्यापारिक जोड़ी पर स्विच करने के बाद, जो पहले गैर-बैकटेस्टिंग पृष्ठ पर सेट किया गया था,trading coins0 है (उदाहरण के लिए, बैकटेस्ट के दौरान, बैकटेस्ट पृष्ठ पर ट्रेडिंग जोड़ी का प्रारंभिक मूल्य हैBTC_USDT, बीटीसी की संख्या 3 है और USDT की संख्या 10000 है।LTC_USDT, की संख्याtrading coinsस्विच करने के बाद 0 होगा, जिसका अर्थ है कि खाते में LTC की संख्या 0 है, लेकिन स्विच किए गए ट्रेडिंग जोड़े की साझा USDT राशि अभी भी 10000 है) ।

function main() {
    var ticker = exchange.GetTicker() 
    Log(ticker)
    Log(exchange.GetAccount())    
    // Switch trading pairs, and pay attention to changes in market quote data and account information after switching
    Log("Switch LTC_USDT: ", exchange.SetCurrency("LTC_USDT"))
    ticker = exchange.GetTicker()
    Log(ticker)
    Log(exchange.GetAccount())
}

def main():
    ticker = exchange.GetTicker()
    Log(ticker)
    Log(exchange.GetAccount())
    Log(" Switch LTC_USDT: ", exchange.SetCurrency("LTC_USDT"))
    ticker = exchange.GetTicker()
    Log(ticker)
    Log(exchange.GetAccount())

void main() {
    auto ticker = exchange.GetTicker();
    Log(ticker);
    Log(exchange.GetAccount());
    exchange.SetCurrency("LTC_USDT");
    Log(" Switch LTC_USDT: ");
    ticker = exchange.GetTicker();
    Log(ticker);
    Log(exchange.GetAccount());
}

बैकटेस्ट ऑपरेशन का परिणाम:

विनिमय.GetQuoteCurrency()

exchange.GetQuoteCurrency()एक्सचेंज द्वारा संचालित आधार मुद्रा का नाम लौटाता है। उदाहरण के लिए,BTC_CNYरिटर्नCNY, औरETH_BTCरिटर्नBTC. रिटर्न मानः स्ट्रिंग प्रकार.

वायदा व्यापार

क्रिप्टोक्यूरेंसी वायदा विनिमय वस्तुओं के लिए, अनुबंध कोड को इसके कॉल करने से पहले निर्दिष्ट किया जाना चाहिएबाजार, आदेशऔर अन्य इंटरफेस, औरexchange.SetContractTypeसमारोह वर्तमान अनुबंध कोड सेट करने के लिए इस्तेमाल किया जाना चाहिए. जब विनिमय वस्तु के वर्तमान व्यापार जोड़ी स्विच, आप कॉल करने की जरूरत हैexchange.SetContractTypeअनुबंध कोड को रीसेट करने के लिए फ़ंक्शन। प्लेटफ़ॉर्म द्वारा समर्थित डिजिटल मुद्रा विनिमय अनुबंध कोड के लिए, कृपया संदर्भित करेंexchange.SetContractType function.

विनिमय.GetPosition()

exchange.GetPosition()वर्तमान स्थिति की जानकारी प्राप्त करता है। रिटर्न मानःpositionअगर कोई स्थिति नहीं है, यह एक खाली सरणी देता है, अर्थात्[].

• Positionसंरचना

आमतौर पर, क्रिप्टोक्यूरेंसी वायदा अनुबंध दो प्रकारों में विभाजित होते हैंः

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

• शाश्वत अनुबंध जब एक अनुबंध एक स्थायी अनुबंध के लिए सेट है, कॉलexchange.GetPosition()फ़ंक्शन, और वर्तमान ट्रेडिंग जोड़ी के तहत स्थायी अनुबंध में सभी पदों को वापस कर दिया जाएगा।

/*
    Note: if there is no position, it will returns an empty array, so you should judge whether the data returned by the interface is a null array, before you use the returned data
    For example:
    When the exchange is set to OKX futures, if the contract is set to be a delivery contract, when the position data of the current week, the next week, and the quarter is obtained, the data type will be an array of position structure.
    When the exchange is set to OKX futures, if the contract is set to a perpetual contract, the array of position structure containing the position data of the perpetual contract will be obtained.
*/

function main(){
    exchange.SetContractType("this_week")
    exchange.SetMarginLevel(10)
    exchange.SetDirection("buy")
    exchange.Buy(10000, 2)
    var position = exchange.GetPosition()
    if(position.length > 0){
        Log("Amount:", position[0].Amount, "FrozenAmount:", position[0].FrozenAmount, "Price:",
            position[0].Price, "Profit:", position[0].Profit, "Type:", position[0].Type,
            "ContractType:", position[0].ContractType)
    }
}

def main():
    exchange.SetContractType("this_week")
    exchange.SetMarginLevel(10)
    exchange.SetDirection("buy")
    exchange.Buy(10000, 2)
    position = exchange.GetPosition()
    if len(position) > 0:
        Log("Amount:", position[0]["Amount"], "FrozenAmount:", position[0]["FrozenAmount"], "Price:", 
            position[0]["Price"], "Profit:", position[0]["Profit"], "Type:", position[0]["Type"], 
            "ContractType:", position[0]["ContractType"])

void main() {
    exchange.SetContractType("this_week");
    exchange.SetMarginLevel(10);
    exchange.SetDirection("buy");
    exchange.Buy(10000, 2);
    auto position = exchange.GetPosition();
    if(position.size() > 0) {
        Log("Amount:", position[0].Amount, "FrozenAmount:", position[0].FrozenAmount, "Price:", 
            position[0].Price, "Profit:", position[0].Profit, "Type:", position[0].Type, 
            "ContractType:", position[0].ContractType);
    } 
}

विनिमय.सेटमार्जिनलेवल(...)

exchange.SetMarginLevel(MarginLevel)लीवरेज आकार सेट करता है। पैरामीटर मानः संख्यात्मक प्रकार।

क्रिप्टोकरेंसी वायदा ऑर्डर लगाने के लिए लीवरेज का आकार सेट करें, उदाहरण के लिएः

function main() {
    exchange.SetMarginLevel(10)
}

def main():
    exchange.SetMarginLevel(10)

void main() {
    exchange.SetMarginLevel(10);
}

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

रणनीतिक डिजाइन में लाभप्रदता निर्धारित करने के लिए नोट्सः

• केवल क्रिप्टोक्यूरेंसी वायदा समर्थित हैं।
• बैकटेस्ट स्विचिंग लीवरेज का समर्थन करता है.

विनिमय.सेटDirection(...)

exchange.SetDirection(Direction)सेटexchange.Buyयाexchange.Sellवायदा आदेशों को रखने के लिए निर्देश बनाने के लिए। पैरामीटर मानः स्ट्रिंग प्रकार।

..SetDirectionफ्यूचर्स ट्रेडिंग दिशा और ऑर्डर प्लेसिंग फ़ंक्शन के बीच का मेल सेट करता है:

ऑर्डर प्लेसिंग फ़ंक्शन	SetDirection फ़ंक्शन के लिए पैरामीटर सेटिंग दिशा	टिप्पणी
exchange.Buy	खरीदें	खुली लंबी स्थिति खरीदें
exchange.Buy	बिक्री बंद	बंद लघु स्थिति खरीदें
exchange.Sell	बेचना	खुली शॉर्ट पोजीशन बेचना
exchange.Sell	closebuy	बंद लंबी स्थिति बेचना

पैरामीटरDirectionचार मापदंडों को ले सकते हैं, जिनमें शामिल हैंbuy, closebuy, sellऔरclosesell.

function main(){
    // Make an example for setting OKX futures weekly contract
    exchange.SetContractType("this_week")    
    // Set 5 times of leverage
    exchange.SetMarginLevel(5)
    // Set the order placing type into placing long order
    exchange.SetDirection("buy")
    // Place an order with the contract quantity of 2, at the price of 10,000
    exchange.Buy(10000, 2)              
    exchange.SetMarginLevel(5)
    exchange.SetDirection("closebuy")
    exchange.Sell(1000, 2)
}

def main():
    exchange.SetContractType("this_week")
    exchange.SetMarginLevel(5)
    exchange.SetDirection("buy")
    exchange.Buy(10000, 2)
    exchange.SetMarginLevel(5)
    exchange.SetDirection("closebuy")
    exchange.Sell(1000, 2)

void main() {
    exchange.SetContractType("this_week");
    exchange.SetMarginLevel(5);
    exchange.SetDirection("buy");
    exchange.Buy(10000, 2);
    exchange.SetMarginLevel(5);
    exchange.SetDirection("closebuy");
    exchange.Sell(1000, 2);
}

exchange.SetContractType ((...)

exchange.SetContractType(ContractType)अनुबंध प्रकार सेट करें. पैरामीटर मानः स्ट्रिंग प्रकार. क्रिप्टोक्यूरेंसी रणनीतियों में, उदाहरण के रूप में BTC_USDT ले लो.exchange.SetCurrency("BTC_USDT")याexchange.IO("currency", "BTC_USDT"), आप का उपयोग करने की जरूरत हैexchange.SetContractTypeप्रणाली यह निर्धारित करती है कि क्या यह एकcurrency-based contractया एकU-based contractके आधार परव्यापारिक जोड़ीउदाहरण के लिए, जब ट्रेडिंग जोड़ी कोBTC_ USDT, उपयोग कार्यexchange.SetContractTypeअनुबंध कोड निर्धारित करने के लिएswap, जो BTC के USDT आधारित शाश्वत अनुबंध के रूप में सेट है।BTC_ USD, उपयोग कार्यexchange.SetContractTypeअनुबंध कोड निर्धारित करने के लिएswap, जो BTC के मुद्रा आधारित स्थायी अनुबंध के रूप में सेट है।

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

• this_week: साप्ताहिक अनुबंध
• next_week: अगले सप्ताह का अनुबंध
• quarter: त्रैमासिक अनुबंध
• next_quarter: अगली तिमाही का अनुबंध

जब तक अन्यथा निर्दिष्ट न हो,शाश्वत अनुबंधक्रिप्टोक्यूरेंसी वायदा अनुबंध में कोड में आम तौर पर निम्नलिखित शामिल होते हैंः

• swap: शाश्वत अनुबंध

वर्तमान अनुबंध को साप्ताहिक अनुबंध पर सेट करें:

function main() {
    // Set to weekly contract
    exchange.SetContractType("this_week") 
}

def main():
    exchange.SetContractType("this_week")

void main() {
    exchange.SetContractType("this_week");
}

प्रत्येक समर्थित क्रिप्टोक्यूरेंसी एक्सचेंज के अनुबंध नामकरण पर विस्तृत विवरण निम्नानुसार दिखाया गया हैः

• ओकेएक्स स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("swap")इस सप्ताह के अनुबंध के लिए सेटःexchange.SetContractType("this_week")अगले सप्ताह अनुबंध के लिए सेटःexchange.SetContractType("next_week")त्रैमासिक अनुबंध के लिए सेट करेंःexchange.SetContractType("quarter")अगली तिमाही के अनुबंध के लिए सेटःexchange.SetContractType("next_quarter")ओकेएक्स यूएसडीटी-मार्जिन किए गए अनुबंध को चालू अनुबंध के अनुरूप यूएसडीटी निपटान का उपयोग करने वाले अनुबंध पर स्विच करके स्विच किया जा सकता हैtrading pairउदाहरण के लिएः

  function main() {
      // The default trading pair is BTC_USD, the contract is set to the weekly contract, and the contract is the crypto-margined contract
      exchange.SetContractType("this_week")
      Log("ticker:", exchange.GetTicker())
      
      // Switch trading pairs, and then set a contract to a USDT-margined contract, which is different from the crypto-margined contract
      exchange.IO("currency", "BTC_USDT")   
      exchange.SetContractType("swap")
      Log("ticker:", exchange.GetTicker())
  }
  

  def main():
      exchange.SetContractType("this_week")
      Log("ticker:", exchange.GetTicker())
      exchange.IO("currency", "BTC_USDT")
      exchange.SetContractType("swap")
      Log("ticker:", exchange.GetTicker())
  

  void main() {
      exchange.SetContractType("this_week");
      Log("ticker:", exchange.GetTicker());
      exchange.IO("currency", "BTC_USDT");
      exchange.SetContractType("swap");
      Log("ticker:", exchange.GetTicker());
  }
  

• फ्यूचर्स_हुओबीडीएम इस सप्ताह के अनुबंध के लिए सेटःexchange.SetContractType("this_week")अगले सप्ताह अनुबंध के लिए सेटःexchange.SetContractType("next_week")त्रैमासिक अनुबंध के लिए सेट करेंःexchange.SetContractType("quarter")अगली तिमाही के अनुबंध के लिए सेटःexchange.SetContractType("next_quarter")स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("swap")

  प्लेटफ़ॉर्म USDT-मार्जिन किए गए अनुबंधों का समर्थन करता है। उदाहरण के रूप में BTC अनुबंध को लें। आप केवल USDT-मार्जिन किए गए अनुबंध पर स्विच कर सकते हैंexchange.SetCurrency("BTC_USDT"), या वर्तमान व्यापारिक जोड़ी कोBTC_USDTसीधे जब आप बॉट मापदंडों को कॉन्फ़िगर और विनिमय वस्तुओं को जोड़ने. व्यापार जोड़ी स्विच करने के बाद, आप कॉल करने की जरूरत हैexchange.SetContractTypeअनुबंध सेट करने के लिए फिर से कार्य।

• फ्यूचर्स_बिटमेक्स स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("XBTUSD"), exchange.SetContractType("APTUSDT"). अनुबंध को किसी विशिष्ट समय पर निपटारा किया जाता है, और अधिक जानकारी के लिए प्रत्येक अनुबंध कोड की जांच करने के लिए BitMEX की आधिकारिक वेबसाइट पर लॉग इन करें। उदाहरण के लिएःexchange.SetContractType("XBTM19").

• फ्यूचर्स_गेटियो इस सप्ताह के अनुबंध के लिए सेटःexchange.SetContractType("this_week"). अगले सप्ताह अनुबंध के लिए सेटःexchange.SetContractType("next_week"). त्रैमासिक अनुबंध के लिए सेट करेंःexchange.SetContractType("quarter"). अगली तिमाही के अनुबंध के लिए सेटःexchange.SetContractType("next_quarter"). स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("swap"). एक्सचेंज USDT-मार्जिन किए गए अनुबंधों का समर्थन करता है। उदाहरण के रूप में BTC अनुबंध लें। आप केवल USDT-मार्जिन किए गए अनुबंध पर स्विच कर सकते हैंexchange.SetCurrency("BTC_USDT"), या वर्तमान व्यापारिक जोड़ी कोBTC_USDTसीधे जब आप लाइव ट्रेडिंग मापदंडों को विन्यस्त और विनिमय वस्तुओं को जोड़ने. व्यापार जोड़ी स्विच करने के बाद, आप कॉल करने की जरूरत हैexchange.SetContractTypeअनुबंध सेट करने के लिए फिर से कार्य।

• फ्यूचर्स_डेरबिट स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("BTC-PERPETUAL")डेरबिट यूएसडीसी अनुबंध का समर्थन; कॉलexchange.SetContractType("ADA_USDC-PERPETUAL")एडीए यूएसडीसी-मार्जिन वाले स्थायी अनुबंध को स्थापित करने के लिए। अनुबंध का निपटारा किसी विशिष्ट समय पर किया जाता है, और अधिक जानकारी के लिए प्रत्येक अनुबंध कोड की जांच करने के लिए Deribit की आधिकारिक वेबसाइट पर लॉग इन करें, जैसेःexchange.SetContractType("BTC-27APR18").

• वायदा_कुकोइन

  • क्रिप्टो-मार्जिन अनुबंध; उदाहरण के लिए, ट्रेडिंग जोड़ी को सेट करेंBTC_USD, और फिर अनुबंध कोड सेट करें, जिसे क्रिप्टो-मार्जिन अनुबंध कहा जाता है। स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("swap")त्रैमासिक अनुबंध के लिए सेट करेंःexchange.SetContractType("quarter")अगली तिमाही के अनुबंध के लिए सेटःexchange.SetContractType("next_quarter")
  • USDT-मार्जिन अनुबंधः उदाहरण के लिए, ट्रेडिंग जोड़ी को सेट करेंBTC_USDT, और फिर अनुबंध कोड सेट करें, जो USDT-मार्जिन किए गए अनुबंध है। स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("swap").

• वायदा_बाइनेंस बिनेंस फ्यूचर्स डिफ़ॉल्ट रूप से कोई अनुबंध स्थिति सेट नहीं करता है, इसलिए आपको पहले अनुबंध सेट करने की आवश्यकता है। स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("swap")Binance वायदा स्थायी अनुबंध USDT-मार्जिन किए गए अनुबंध हो सकते हैं।BTCUSDT-मार्जिन वाला अनुबंध, ट्रेडिंग जोड़ी कोBTC_USDT. बिनेंस फ्यूचर्स परपेचुअल कॉन्ट्रैक्ट्स में क्रिप्टो-मार्जिन किए गए कॉन्ट्रैक्ट भी शामिल हैं। उदाहरण के लिए, क्रिप्टो-मार्जिन किए गए कॉन्ट्रैक्ट में, ट्रेडिंग जोड़ी को सेट करेंBTC_USD.

  त्रैमासिक अनुबंध के लिए सेट करेंःexchange.SetContractType("quarter")वितरण अनुबंधों में क्रिप्टो-मार्जिन किए गए अनुबंध शामिल हैं (अर्थात उपयोग की जाने वाली मुद्रा को मार्जिन के रूप में लेते हुए) ।BTC, व्यापारिक जोड़ी को सेट किया गया हैBTC_USD, और फिर अनुबंध कोड सेटexchange.SetContractType("quarter"), जो BTC क्रिप्टो-मार्जिन त्रैमासिक अनुबंध सेट कर रहा है।

  अगली तिमाही के अनुबंध के लिए सेटःexchange.SetContractType("next_quarter")उदाहरण के लिए, त्रैमासिक क्रिप्टो-मार्जिन किए गए अनुबंध मेंBTC, व्यापारिक जोड़ी को सेट किया गया हैBTC_USD, और फिर अनुबंध कोड सेटexchange.SetContractType("next_quarter). बिनेंस USDT-मार्जिन किए गए वितरण अनुबंधों के हिस्से का समर्थन करता है, जैसे कि BTC ट्रेडिंग जोड़ी कोBTC_USDT, और फिर अनुबंध कोड सेट करें।

• वायदा_बिबॉक्स Bibox स्थायी अनुबंध कोडःswap. स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("swap").

• फ्यूचर्स_एओएफएक्स AOFEX स्थायी अनुबंध कोडःswap. स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("swap").

• फ्यूचर्स_बीएफएक्स BFX स्थायी अनुबंध कोडःswap. स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("swap").

• फ्यूचर्स_बीबिट Bybit वर्तमान ट्रेडिंग जोड़ी के स्थायी अनुबंध के लिए डिफ़ॉल्ट है। अनुबंध कोडःswap. त्रैमासिक अनुबंध कोडःquarter. अगली तिमाही अनुबंध कोडःnext_quarter.

• फ्यूचर्स_क्रैकेन क्रैकन डिफ़ॉल्ट रूप से कोई अनुबंध स्थिति सेट करने के लिए, तो आप अनुबंध कोड सेट करने की जरूरत है। अनुबंध कोडःswap: शाश्वत अनुबंध।month: मासिक अनुबंध।quarter: त्रैमासिक अनुबंध।next_quarterअगले तिमाही का अनुबंध।

• फ्यूचर्स_बिटफाइनएक्स Bitfinex वर्तमान ट्रेडिंग जोड़ी के स्थायी अनुबंध के लिए डिफ़ॉल्ट करता है। अनुबंध कोडःswap.

• फ्यूचर्स_बिटगेट बिटगेट वर्तमान ट्रेडिंग जोड़ी के स्थायी अनुबंध के लिए डिफ़ॉल्ट है। अनुबंध कोडःswap. व्यापारिक जोड़ी पर सेट हैBTC_USD, क्रिप्टो-मार्जिन किए गए अनुबंध को दर्शाता है; ट्रेडिंग जोड़ी को सेट किया गया हैBTC_USDT, USDT-मार्जिन किए गए अनुबंध को दर्शाता है। अनुकरण किए गए अनुबंध व्यापारिक जोड़े को निम्न में सेट कर सकते हैंःSBTC_USDऔरBTC_SUSDT.

• फ्यूचर्स_डीवाईडीएक्स dYdX स्थायी अनुबंध का अनुबंध कोडःswap. स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("swap"). dYdX में केवल USDT-मार्जिन किए गए अनुबंध हैं।

• फ्यूचर्स_मेक्सिको एमईएक्ससी स्थायी अनुबंध का अनुबंध कोडःswap. स्थायी अनुबंध पर सेट करेंःexchange.SetContractType("swap"). व्यापारिक जोड़ी पर सेट हैBTC_USD, क्रिप्टो-मार्जिन किए गए अनुबंध को दर्शाता है; ट्रेडिंग जोड़ी को सेट किया गया हैBTC_USDT, जो USDT मार्जिन वाले अनुबंध को दर्शाता है।

क्रिप्टोक्यूरेंसी रणनीतियाँ लिखते समय, कॉलexchange.SetContractType(ContractType)कार्य और अनुबंध पैरामीटर द्वारा निर्धारित विस्तृत अनुबंध जानकारीContractTypeलौटा दिया जाएगा।

उदाहरण के लिए, विनिमय वस्तु के रूप में सेट OKX अनुबंध की रणनीति कोड चलानेः

function main(){
    // Set to weekly contract
    var ret = exchange.SetContractType("this_week")     
    // Return the information of the weekly contract
    Log(ret)
}

def main():
    ret = exchange.SetContractType("this_week")
    Log(ret)

void main() {
    auto ret = exchange.SetContractType("this_week");
    Log(ret);
}

में रणनीति चलाएँJavaScriptभाषा और मुद्रणretडेटा, अर्थात् विस्तृत जानकारीthis_weekअनुबंध:

{
    "instrument":"BTC-USD-191101",
    "InstrumentID":"BTC-USD-191101"
}   

exchange.GetContractType (()

exchange.GetContractType()एक्सचेंज ऑब्जेक्ट का वर्तमान में सेट अनुबंध कोड लौटाता है (exchange), रिटर्न मानः स्ट्रिंग.

function main () {
    Log(exchange.SetContractType("this_week")) 
    Log(exchange.GetContractType())
}

def main():
    Log(exchange.SetContractType("this_week"))
    Log(exchange.GetContractType())

void main() {
    Log(exchange.SetContractType("this_week"));
    Log(exchange.GetContractType());
}

फ्यूचर्स_ओपी त्रुटियाँ

निम्नलिखित तालिका क्रिप्टोकरेंसी वायदा अनुबंधों के विनिमय वस्तुओं से संबंधित त्रुटि जानकारी का वर्णन करती हैः

मूल्य	फ़ंक्शन प्रदर्शन त्रुटि	ट्रिगर फ़ंक्शन	विवरण
0	फ्यूचर्स_ओपी 0	exchange.SetMarginLevel	लीवरेज फ़ंक्शन को बुलाने की त्रुटि
1	फ्यूचर्स_ओपी 1	exchange.SetDirection	फ्यूचर्स ट्रेडिंग दिशा फंक्शन सेट करने की त्रुटि
2	फ्यूचर्स_ओपी 2	exchange.SetContractType	अनुबंध कार्य को स्थापित करने में त्रुटि
3	फ्यूचर्स_ओपी 3	exchange.GetPosition	स्थिति फ़ंक्शन प्राप्त करने में त्रुटि
4	फ्यूचर्स_ओपी 4	exchange.IO	आईओ फ़ंक्शन को बुलाने में त्रुटि

विकल्प व्यापार

क्रिप्टोकरेंसी विकल्प

प्रयोगexchange.SetContractTypeविभिन्न एक्सचेंजों के पास भिन्न विकल्प अनुबंध कोड होते हैं।

एफएमजेड क्वांट ट्रेडिंग प्लेटफॉर्म द्वारा समर्थित क्रिप्टोकरेंसी विकल्प एक्सचेंजों

• डेरबिट डेरबिट एक्सचेंज के लिए, यह केवल आवश्यक हैexchange.SetContractTypeविकल्प अनुबंध स्थापित करने के बाद, बाजार इंटरफ़ेस जैसेGetTicker, विकल्प अनुबंध के सभी बाजार डेटा प्राप्त किया जाता है।exchange.Sellऔरexchange.Buyऑर्डर देने के लिए कार्य करता है, और ऑर्डर देते समय ट्रेडिंग दिशा पर ध्यान देता है, और ट्रेडिंग दिशा निर्धारित करता हैexchange.SetDirection.exchange.Cancelएक आदेश रद्द करने के लिए कार्य;exchange.GetPositionपदों को क्वेरी करने के लिए फ़ंक्शन।

  संदर्भ के लिए रणनीति कोडःडेरिबिट विकल्पों की परीक्षण रणनीति

• ओकेएक्स अनुबंध बनाना, ऑर्डर देना, ऑर्डर रद्द करना, ऑर्डर की जांच करना और बाजार के उद्धरण प्राप्त करना, आदि उसी ऑपरेशन के हैं जैसे किDeribit, और अनुबंध कोड प्रारूप हैBTC-USD-200626-4500-C. आप इंटरफेस के माध्यम से अनुबंध से संबंधित जानकारी पूछ सकते हैंhttps://www.okx.com/api/v5/public/instruments.

  उदाहरण के लिए, बीटीसी विकल्प अनुबंधों की जानकारी की क्वेरी करने के लिएः

  function main() {
      Log(HttpQuery("https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD"))
  }
  

  import json
  import urllib.request
  def main():
      ret = json.loads(urllib.request.urlopen("https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD").read().decode('utf-8'))
      Log(ret)
  

  void main() {
      Log(HttpQuery("https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD"));
  }
  

• फ्यूचर्स_हुओबीडीएम उदाहरण के लिए, Huobi विकल्प अनुबंध कोडःBTC-USDT-201225-P-13000; यह अनुबंधBTCअनुबंध; व्यायाम की तारीख 25 दिसंबर 2020 है; विकल्प पुट विकल्प (PUT) हैं; स्ट्राइक मूल्य $13,000 है। कॉल विकल्पों के लिए, खरीदार द्वारा भुगतान किया गया प्रीमियम USDT है, जो खाता परिसंपत्तियों में USDT का उपयोग किया जाता है; विक्रेता का मार्जिन मुद्रा है, जो परिसंपत्तियों में मुद्रा द्वारा गारंटीकृत है। विक्रय विकल्पों के लिए, खरीदार द्वारा भुगतान किया गया प्रीमियम USDT है, यह दर्शाता है कि खाता परिसंपत्तियों में USDT का उपयोग किया गया है; विक्रेता का मार्जिन USDT है, जो परिसंपत्तियों में USDT द्वारा गारंटीकृत है।

• फ्यूचर्स_बीबिट यह Bybit एक्सचेंज के USDC विकल्प का समर्थन करता है, और ट्रेडिंग जोड़ी कोETH_USDC, कॉल फ़ंक्शनexchange.SetContractTypeअनुबंध को विकल्प अनुबंध के रूप में सेट करने के लिए। विकल्प अनुबंध कोड का उदाहरणःETH-25NOV22-1375-P.

नेटवर्क सेटिंग्स

exchange.SetBase(Base)

..exchange.SetBase(Base)समारोह का उपयोग विनिमय वस्तुओं में दर्ज एपीआई आधार पते स्विच करने के लिए किया जाता है; उदाहरण के लिए, स्विच करने के लिएOKXडोमेन नामhttps://aws.okx.com, के साथ संगतexchange.IO("base","https://aws.okx.com")स्विचिंग विधि. बैकटेस्ट सिस्टम एक्सचेंज के एपीआई आधार पते को स्विच करने का समर्थन नहीं करता है (बैकटेस्ट सिस्टम एक सैंडबॉक्स वातावरण है, एक्सचेंज तक पहुंचने के लिए एक वास्तविक इंटरफ़ेस नहीं है) ।

function main() {
    // Use the default base address
    Log(exchange.GetTicker())
    // Switch to https://aws.okx.com
    exchange.SetBase("https://aws.okx.com")
    Log(exchange.GetTicker())
}

def main():
    Log(exchange.GetTicker())
    exchange.SetBase("https://aws.okx.com")
    Log(exchange.GetTicker())

void main() {
    Log(exchange.GetTicker());
    exchange.SetBase("https://aws.okx.com");
    Log(exchange.GetTicker());
}

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

exchange.SetProxy(...)एक्सचेंज का उपयोग करने के लिए प्रॉक्सी सर्वर पर स्विच करता है. इस फ़ंक्शन का कोई रिटर्न मान नहीं है (परिवर्तनशील द्वारा प्राप्त, और आप क्या प्राप्त हैundefined) यदि प्रॉक्सी सेटिंग विफल हो जाती है, तो इंटरफ़ेस को बुलाए जाने पर शून्य मान लौटाया जाएगा, केवलआराम करनाप्रत्येक विनिमय वस्तुexchanges[n]प्रॉक्सी सेट करने के बाद, एक्सचेंज इंटरफेस प्रॉक्सी के माध्यम से एक्सेस किया जाएगा.

पहला जोड़ा विनिमय ऑब्जेक्ट ले लोexchangeअर्थात्:exchanges[0]उदाहरण के लिएः

• प्रॉक्सी सेट करें, उपयोगकर्ता नाम और पासवर्ड के बिना:exchange.SetProxy("socks5://127.0.0.1:8889")
• प्रॉक्सी सेट करें, और उपयोगकर्ता नाम और पासवर्ड दर्ज करें:exchange.SetProxy("socks5://username:password@127.0.0.1:8889") (usernameउपयोगकर्ता का नाम है,passwordपासवर्ड है)
• सामान्य मोड पर स्विच करें, प्रॉक्सी के बिनाःexchange.SetProxy("")

एक्सचेंज ऑब्जेक्ट द्वारा अनुरोधित आईपी पते को सेट करने के लिए समर्थन।

• वैश्विक विनिर्देश के डॉकरwindowsसिस्टम इंटरफ़ेस संस्करण सीधे सेट किया जा सकता है, जो निम्न चित्र के रूप में दिखाया गया हैः

कमांड प्रॉम्प्ट उपयोग पैरामीटर द्वारा संचालित अन्य डॉकर-Iआईपी पते निर्दिष्ट करने के लिएः

• विनिमय के आधार पर निर्दिष्ट करेंः

  function main(){
      exchange.SetProxy("ip://10.0.3.15")
      exchange.GetTicker()                      // The reque

अधिक