FMZ-API-Anweisungen

pp Nicht mehr verfügbar. Ausgleichszahlungen [0].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());
}

• Wechseln des Marktmodus Aktuell unterstützte Börsen:

  Austausch	Anmerkungen
  Huobi Spot	Nach Unterstützung des WebSocket-Protokolls wird der Codeexchange.IO(Währung, ETH) kann nicht zum Wechseln von Währungen verwendet werden

  • exchange.IO("websocket")

    Wechseln Sie das Marktkommunikationsprotokollwebsocket(Standard ist Ruhe), wird sich die Art und Weise, wie die Marktkurse erhalten werden, nach dem Wechsel ändern.exchange.GetTicker()undexchange.GetDepth()wird aufwebsocketDas Protokoll wird von der rohen aktiven Akquisition von Marktdaten bis zur passiven Akquisition von Marktdaten aktualisiert.

  Wenn der Marktmodus der Push-Mechanismus ist, kann die folgende Funktion eingestellt werden:

  • exchange.IO("mode", 0)Sofortiger Rückkehrmodus. Wenn der aktuelle Marktdaten-Push nicht von der Börse empfangen wurde, werden die alten Marktdaten sofort zurückgegeben. Wenn es neue Daten gibt, werden die neuen Daten zurückgegeben.

  • exchange.IO("mode", 1)Cache-Modus (Standardmodus). Wenn die neuesten Marktdaten der Börse nicht empfangen wurden (im Vergleich zu den Daten, die aus der vorherigen Schnittstelle erhalten wurden), warten Sie auf den Empfang und kehren Sie dann zurück. Wenn die neuesten Marktdaten empfangen wurden, bevor Sie diese Funktion anrufen, werden die neuesten Daten sofort zurückgegeben.

  • exchange.IO("mode", 2)Zwangsupdate-Modus. Geben Sie ein und warten Sie, bis die nächsten neuesten Push-Daten der Börse empfangen werden und dann zurückkehren.

  Wenn Sie die neuesten Marktinformationen zum ersten Mal erhalten möchten, können Sie aufwebsocketund ruft nichtSleepDie Daten werden sofort getestet.exchange.GetTicker()undexchange.GetDepth()Funktionen arbeiten im Cache-Modus, wie z. B.:

  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());
      }
  }
  

• Wechselkursfinanzierungskonto

  Verwendungexchange.IO("trade_margin")Um auf den Hebelkonto-Modus zu wechseln, werden bei der Abgabe von Aufträgen und beim Zugriff auf Kontovermögen die Hebelwirbeloberfläche der Börse verwendet. Verwendungexchange.IO("trade_normal")Zurück zum normalen Konto-Modus.

  Unterstützte Austauschstellen:

  Austausch	Besondere Bemerkungen
  OKX	Die Handelspaare des Hebelwirkungskonto-Modus unterscheiden sich von den gewöhnlichen und einige Handelspaare sind möglicherweise nicht verfügbar.exchange.IO("cross", true)zur Umstellung auf die volle Position des Hebelkontos undexchange.IO("cross", false)Umschalten in eine isolierte Position.
  Weiß nicht.	Die Handelspare des Hebelwirkungskonto-Modus unterscheiden sich von den gewöhnlichen und einige Handelspare sind möglicherweise nicht verfügbar.trade_marginzur Umstellung auf eine isolierte Position auf einem Leveragekonto;trade_super_marginfür die Umstellung auf eine Position, die auf einem Hebelkonto gekreuzt wurde;trade_normalzum Wechsel in einen normalen Währungsmodus
  ZB	Die Mittel können nur in QC überwiesen werden. Im Leverage-Handelssektor sind die Mittel zwischen verschiedenen Handelsparen unabhängig, d. h. die Anzahl der QC-Münzen unter dem ETH_QC-Handelspare ist in BTC_QC nicht sichtbar
  Binance	Die Leverage-Konten sind in gekreuzte und isolierte Positionen unterteilt.trade_marginzum Wechsel in eine isolierte Position;trade_super_marginzur Umstellung auf die gekreuzte Position;trade_normalzum Wechsel in einen normalen Währungsmodus
  Schnittstelle	Die Leverage-Konten sind in gekreuzte und isolierte Positionen unterteilt.trade_marginzum Wechsel in eine isolierte Position;trade_super_marginzur Umstellung auf die gekreuzte Position;trade_normalzum Wechsel in einen normalen Währungsmodus
  AscendEx	Verwendungexchange.IO("trade_margin")um auf den Hebelkonto-Modus zu wechseln undexchange.IO("trade_normal")Zurück zum normalen Konto-Modus.

Auswechselung.Log ((...)

exchange.Log(LogType, Price, Amount)wird bei Aufruf nicht bestellt und erfasst nur Handelsinformationen, um die Informationen des Börsengangs auszugeben.

Anmerkung:

• Diese Funktion ist eine Mitgliederfunktion vonexchangeObjekte, die sich von der globalen Funktion unterscheidenLog().
• Parameterwert:LogTypekann nehmenLOG_TYPE_BUY, LOG_TYPE_SELL, LOG_TYPE_CANCELundPriceals Preis undAmountals Quantität.LogTypeistLOG_TYPE_CANCEL, PriceParameter ist die Auftrags-ID.

Verwendungexchange.Log(LogType, Price, Amount)die Durchführung von Live-Handels-Folgetests, simulierte Auftragsvergabe und Unterstützung bei der Aufzeichnung von Aufträgen.

Der häufigste Anwendungsfall ist:exchange.IODiese Funktion erlaubt es, die Schnittstelle für die Erstellung bedingter Aufträge der Börse zu nutzen, um bedingte Aufträge zu platzieren.exchange.IODie Funktion wird nicht die Exchange-Log-Informationen in der Bot-Log-Aufzeichnung ausgeben.exchange.Log(LogType, Price, Amount)um die Log-Ausgabe zu ergänzen, um die Informationen zur Auftragserteilung zu erfassen.

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);
}

Auswechselung.HMAC(...)

exchange.HMAC(Algo, OutputAlgo, Data, Key)unterstützt dieHMACVerschlüsselungsberechnungMd5/SHA256/SHA512/SHA1, und nur Live-Trading wird unterstützt.

exchange.HMAC("sha256", "hex", "xxxxx", "{{secretkey}}")Ich zitiere:accessKey, verwenden"{{accesskey}}"- Ich weiß. Ich zitiere:secretKey, verwenden"{{secretkey}}"; oder Sie können einfachen Text verwenden"abc-123-xxxx". "{{accessKey}}","{{secretkey}}"gilt nur, wenn diese Funktion verwendet wird.OutputAlgoStützen: hex, base64.Konkretes Beispiel

Push BitMEX-Positionsänderungen (wss-Protokoll)

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"];
        }
    }
}

- Ich bin nicht derjenige.

exchange.Go(Method, Args...)ist die mehrthreaded asynchrone unterstützte Funktion, die den Betrieb aller unterstützten Funktionen in asynchrone Gleichzeitigkeit (die nur Kryptowährungsbörsen unterstützt) umwandeln kann. Parameterwert:Method, von String-Typ, nämlich der gleichzeitig aufgerufene Funktionsname.

Anmerkung:

• Diese Funktion erzeugt nur mehrthreaded-Ausführungsaufgaben, wenn sie im Live-Handel ausgeführt werden.
• Nach derexchange.GoFunktion gibt ein Objekt zurück, diewaitDer Thread wird automatisch nach der Datenerfassung freigegeben, indem erwaitWenn der Timeout-Parameter vonwait, wird der Thread nicht freigegeben, selbst wenn der Timeout eintritt; auf diese Weise wird der Thread automatisch nur durch Erhalt des Thread-Ergebnisses freigegeben (egal ob die gleichzeitig zugegriffene Schnittstelle erfolgreich oder erfolglos aufgerufen wird).
• Einfach ausgedrückt: Egal, ob der angewandte Faden erfolgreich ist oder nicht, das Ergebnis muss durch diewaitFunktion, und die von derexchange.GoFunktion wird automatisch vom Docker freigegeben.
• Wenn das Ergebnis derwaitWenn die Funktion am Ende nicht erreicht wird, werden die Thread-Ressourcen nicht automatisch freigesetzt, was zur Anhäufung von angewandten Threads führt; wenn die Anzahl der Threads 2000 übersteigt, wird ein Fehler gemeldet:"too many routine wait, max is 2000".

Unterstützte Funktionen:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositionundIO.

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);
}

Anmerkung:

• Um zu beurteilenundefined, verwendentypeof(xx)==="undefined", weilnull == undefinedist in JavaScript verfügbar.

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);
}

Der Unterschied zwischenPythonundJavaScriptIst das das?PythonDas ist...waitFunktion gibt zwei Parameter zurück: das erste ist das Ergebnis, das von der asynchronen API zurückgegeben wird; das zweite gibt an, ob der asynchrone Aufruf abgeschlossen ist.

PythonBeispiel:

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)       

Erhalten Sie gleichzeitig mehrere Börsennotierungen:

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);
    }
}

Gleichzeitige Aufrufe an dieexchange.IO("api", ...)Funktion:

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");
}

Kontoinformationen

- Ich bin nicht bereit.

exchange.GetAccount()Gibt die Informationen des Umtauschkontos zurück.Account structure.

• AccountStruktur

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);
}

Wenn das Austauschobjekt auf eine Kryptowährungs-Futures-Börse gesetzt und auf einen Vertrag mitUSDTals Marge (sieheexchange.SetContractTypeDie Vermögenswerte werden von derUSDTals Marge, die im AttributBalanceundFrozenBalance.

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);
}

Erstmals.GetName

exchange.GetName()Returns value: String-Typ. Im Allgemeinen wird es verwendet, um dieexchangeoderexchanges[n]Objekte im Strategiecode.

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");
}

Für das Befehlen der Zeilenversion von Docker können Sie die-1Befehl zum Drucken einer Liste von Austauschnamen.

Auswechselung.GetLabel

exchange.GetLabel()Gibt das benutzerdefinierte Label des Austauschs zurück.

Dieexchangeoderexchanges[n]Objekte in Strategiecodes werden normalerweise durch die beim Konfiguration der Austauschobjekte festgelegten Etiketten bestimmt.

Wechsel.GetCurrency(

exchange.GetCurrency()gibt den Namen des von der Börse betriebenen Währungspaares zurück, und die Kryptowährungsplattform gibt eine Zeichenfolge zurück, z. B.LTC_BTC. Rückgabewert: Zeichenfolge.

Wechselkurs.Währungsumwandlung.

Dieexchange.SetCurrency(Symbol)Funktion wird verwendet, um das aktuelle Handelspaar des Tauschobjekts zu wechseln.exchange.IO ("currency","BTC_USDT")Es unterstützt das Wechseln von Handelsparen im Backtesting-System und den Namen derpricing currencykann nicht geändert werden, wenn im Backtesting-System von Handelsparen gewechselt wird (z. B.BTC_USDTkann aufLTC_USDT, aber es kann nicht aufLTC_BTCNach der Umstellung auf ein Handelspaar, das ursprünglich auf der Seite ohne Backtesting gesetzt wurde, wird die Anzahl dertrading coinsist 0 (z. B. ist der Anfangswert des Handelspares auf der Backtestseite während des Backtests 0BTC_USDT, ist die Anzahl der BTC 3, und die Anzahl der USDT ist 10.000.LTC_USDT, die Anzahl dertrading coinsNach dem Wechsel beträgt 0, was bedeutet, dass die Anzahl der LTC auf dem Konto 0 beträgt, der geteilte USDT-Betrag der wechselnden Handelspare jedoch immer noch 10000 beträgt).

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());
}

Das Ergebnis des Backtestbetriebs:

Wechsel.GetQuoteWährung

exchange.GetQuoteCurrency()gibt den Namen der Basiswährung zurück, die von der Börse betrieben wird.BTC_CNYErträgeCNY, undETH_BTCErträgeBTC. Rückgabewert: Zeichenfolge.

Futures-Handel

Für die Kryptowährungs-Futures-Börsen muss der Vertragskode vor dem Anruf desMarkt, Ordnungund andere Schnittstellen, und dieexchange.SetContractTypeWenn Sie das aktuelle Handelspaar des Austauschobjekts wechseln, müssen Sie dieexchange.SetContractTypeFür die von der Plattform unterstützten Codes für digitale Währungsumtauschverträge sieheexchange.SetContractType function.

Wechsel.GetPosition ((()

exchange.GetPosition()Erhält die aktuelle Positionsinformation.positionWenn es keine Position gibt, gibt es ein leeres Array zurück, nämlich[].

• PositionStruktur

Normalerweise werden die Kryptowährungs-Futures-Kontrakte in zwei Arten unterteilt:

• Liefervertrag Wenn ein Vertrag auf einen Liefervertrag eingestellt ist, rufen Sie dieexchange.GetPosition()Die in Artikel 2 Absatz 1 Buchstabe b genannten Positionen werden in der Regel in der Regel in der Liste der Positionen angegeben, die in den einzelnen Positionen des Liefervertrags enthalten sind.

• Ein Vertrag auf Dauer Wenn ein Vertrag auf einen dauerhaften Vertrag eingestellt ist, rufen Sie dieexchange.GetPosition()Die Angabe der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung der Anpassung.

/*
    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);
    } 
}

Wechselkurs.Margin-Level festlegen.

exchange.SetMarginLevel(MarginLevel)Der Wert des Parameters: numerischer Typ.

Einrichtung der Hebelwirkung für die Platzierung von Futures-Orders für Kryptowährungen, z. B.:

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

def main():
    exchange.SetMarginLevel(10)

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

Für Kryptowährungs-Futures sind die Hebelmechanismen der Kryptowährungs-Futures-Börsen nicht einheitlich.SetMarginLevelDie Funktion kann keine Netzwerkanfrage generieren, sondern setzt lediglich die Hebelwirkungsschwingungsvariable in der unteren Schicht (verwendet zur Übergabe von Parametern in der Platzierungsaufgabeoberfläche). Die Futures-Leverage von einigen Börsen ist eine Einstellung der Börse, die auf der Website der Börse oder über die API-Oberfläche festgelegt werden muss.SetMarginLevelDie Funktion wird eine Netzwerkanfrage generieren und kann aus verschiedenen Gründen den Hebel nicht setzen. Zum Beispiel: Wenn es aktuelle Positionen und ausstehende Aufträge gibt, kann der Hebelwert für dieses Handelspaar und das zugrunde liegende Objekt nicht festgelegt werden.

Anmerkungen zur Festlegung der Hebelwirkung im Rahmen der Strategieplanung:

• Nur Kryptowährungs-Futures werden unterstützt.
• Der Backtest unterstützt das Wechseln von Hebeln.

Wechsel.SetDirection ((...)

exchange.SetDirection(Direction)Satzexchange.Buyoderexchange.SellParameterwert: Zeichenfolgeart.

DieSetDirectionFunktion setzt die Korrespondenz zwischen der Futures-Handelsrichtung und der Auftragsvergabefunktion:

Funktion zur Auftragserteilung	Parameter-Einstellungsrichtung für SetDirection Funktion	Anmerkungen
exchange.Buy	kaufen	Kauf einer offenen Long-Position
exchange.Buy	Schließverkäufe	kurzfristige Positionen schließen
exchange.Sell	verkaufen	Verkauf einer offenen Leerposition
exchange.Sell	Kleiner Kauf	Verkauf einer langen Position

Der ParameterDirectionkann die vier Parameter, einschließlichbuy, closebuy, sellundclosesell.

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);
}

Auswechselung.SetContractType(...)

exchange.SetContractType(ContractType)Setzen Sie den Vertragstyp. Parameterwert: String-Typ. In Kryptowährungsstrategien, nehmen Sie BTC_USDT als Beispiel.exchange.SetCurrency("BTC_USDT")oderexchange.IO("currency", "BTC_USDT"), müssen Sie dieexchange.SetContractTypeDas System ermittelt, ob es sich um einen neuen Handelspartner handelt.currency-based contractoder aU-based contractauf der GrundlageHandelspaar. Zum Beispiel, wenn das Handelspar aufBTC_ USDT, Nutzung Funktionexchange.SetContractTypeUm den Vertragskode festzulegenswap, der als USDT-basierter Dauervertrag von BTC festgelegt wird.BTC_ USD, Nutzung Funktionexchange.SetContractTypeUm den Vertragskode festzulegenswap, der als der währungsbasierte dauerhafte Vertrag von BTC festgelegt wird.

Sofern nicht anders angegeben:LiefervertragCode in einem Kryptowährungs-Futures-Kontrakt umfasst im Allgemeinen:

• this_week: wöchentlicher Vertrag
• next_week: nächstes Wochenvertrag
• quarter: vierteljährlicher Vertrag
• next_quarter: Vertrag für das nächste Quartal

Sofern nicht anders angegeben:DauervertragCode in einem Kryptowährungs-Futures-Kontrakt umfasst im Allgemeinen:

• swap: Dauervertrag

Setzen Sie den aktuellen Vertrag auf einen wöchentlichen Vertrag:

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

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

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

Eine detaillierte Beschreibung der Vertragsbezeichnung jeder unterstützten Kryptowährungsbörse ist wie folgt dargestellt:

• OKX Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap")Für diese Woche:exchange.SetContractType("this_week")Vertrag für nächste Woche:exchange.SetContractType("next_week")Auf den vierteljährlichen Vertrag:exchange.SetContractType("quarter")Für das nächste Quartal:exchange.SetContractType("next_quarter")OKX USDT-Margin-Kontrakt kann auf den Kontrakt mit USDT-Abwicklung, der dem aktuellen Vertrag entspricht, umgestellt werden, indemtrading pair(oder sie direkt beim Hinzufügen der Austauschobjekte einstellen).

  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());
  }
  

• Futures_HuobiDM Für diese Woche:exchange.SetContractType("this_week")Vertrag für nächste Woche:exchange.SetContractType("next_week")Auf den vierteljährlichen Vertrag:exchange.SetContractType("quarter")Für das nächste Quartal:exchange.SetContractType("next_quarter")Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap")

  Die Plattform unterstützt die USDT-Margin-Kontrakte. Nehmen Sie den BTC-Kontrakt als Beispiel. Sie können nur auf einen USDT-Margin-Kontrakt wechseln, indem Sieexchange.SetCurrency("BTC_USDT"), oder indem das aktuelle Handelspaar aufBTC_USDTNach dem Wechseln des Handelspaares müssen Sie anrufenexchange.SetContractTypeFunktion wieder, um den Vertrag festzulegen.

• Futures_BitMEX Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("XBTUSD"), exchange.SetContractType("APTUSDT")- Ich weiß. Der Vertrag wird zu einem bestimmten Zeitpunkt abgewickelt, und melden Sie sich auf der offiziellen Website von BitMEX an, um jeden Vertragskode für weitere Details zu überprüfen.exchange.SetContractType("XBTM19").

• Futures_GateIO Für diese Woche:exchange.SetContractType("this_week")- Ich weiß. Vertrag für nächste Woche:exchange.SetContractType("next_week")- Ich weiß. Auf den vierteljährlichen Vertrag:exchange.SetContractType("quarter")- Ich weiß. Für das nächste Quartal:exchange.SetContractType("next_quarter")- Ich weiß. Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap")- Ich weiß. Die Börse unterstützt die USDT-Margin-Kontrakte. Nehmen Sie den BTC-Kontrakt als Beispiel. Sie können nur auf einen USDT-Margin-Kontrakt wechseln, indem Sieexchange.SetCurrency("BTC_USDT"), oder indem das aktuelle Handelspaar aufBTC_USDTNach dem Wechseln des Handelspaares müssen Sie dieexchange.SetContractTypeFunktion wieder, um den Vertrag festzulegen.

• Futures_Deribit Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("BTC-PERPETUAL")Unterstützung des USDC-Vertrags der Deribit; Aufrufexchange.SetContractType("ADA_USDC-PERPETUAL")die Festlegung eines ADA-USDC-Margin-Perpetuum-Kontrakts. Der Vertrag wird zu einem bestimmten Zeitpunkt abgewickelt, und melden Sie sich auf der offiziellen Website von Deribit an, um jeden Vertragskode für weitere Details zu überprüfen, wie:exchange.SetContractType("BTC-27APR18").

• Futures_KuCoin

  • Die Risikopositionen werden in den folgenden Kategorien aufgeführt: Zum Beispiel setzen Sie das Handelspaar aufBTC_USD, und dann den Vertragskode, der als Krypto-Margin-Vertrag bezeichnet wird. Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap")Auf den vierteljährlichen Vertrag:exchange.SetContractType("quarter")Für das nächste Quartal:exchange.SetContractType("next_quarter")
  • USDT-Margin-Vertrag: Zum Beispiel setzen Sie das Handelspaar aufBTC_USDT, und dann den Vertragskode, der USDT-Margin-Kontrakt ist. Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap").

• Futures_Binance Binance Futures setzt standardmäßig keinen Vertragsstatus fest, also müssen Sie zuerst den Vertrag festlegen. Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap")Binance Futures können USDT-Margin-Kontrakte sein.BTCUSDT-Margin-Kontrakt, das Handelspaar ist aufBTC_USDTBinance Futures-Perpetual Contracts umfassen auch Krypto-Margin-Kontrakte.BTC_USD.

  Auf den vierteljährlichen Vertrag:exchange.SetContractType("quarter")Die Lieferverträge umfassen Krypto-Margin-Verträge (d. h. die verwendete Währung als Margin).BTC, ist das Handelspaar aufBTC_USD, und setzen Sie dann den Vertragskodeexchange.SetContractType("quarter"), die BTC-Krypto-Margin Quartalsvertrag festlegt.

  Für das nächste Quartal:exchange.SetContractType("next_quarter")Zum Beispiel im vierteljährlichen Krypto-Margin-Kontrakt vonBTC, ist das Handelspaar aufBTC_USD, und setzen Sie dann den Vertragskodeexchange.SetContractType("next_quarter)Binance unterstützt einen Teil der USDT-marginierten Lieferverträge, wie z. B. die Einstellung des BTC-Handelspaares aufBTC_USDT, und dann setzen Sie den Vertragskode.

• Futures_Bibox Code für den Bibox-Perpetual-Vertrag:swap- Ich weiß. Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap").

• Futures_AOFEX AOFEX-Perpetual Contract Code:swap- Ich weiß. Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap").

• Futures_BFX BFX-Perpetual Contract-Code:swap- Ich weiß. Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap").

• Futures_Bybit Bybit ist für den dauerhaften Vertrag des aktuellen Handelspares standardisiert.swap- Ich weiß. Quartalsvertragskode:quarter- Ich weiß. Vertragskode für das nächste Quartal:next_quarter.

• Futures_Kraken Kraken setzt standardmäßig keinen Vertragszustand fest, also müssen Sie den Vertragscode festlegen.swap: Vertrag auf Dauer.month: monatlicher Vertrag.quarter: vierteljährlicher Vertrag.next_quarterDer nächste Quartalsvertrag.

• Futures_Bitfinex Bitfinex ist dem Vertrag des aktuellen Handelspaares nicht verpflichtet.swap.

• Futures_Bitget Bitget setzt den dauerhaften Vertrag des aktuellen Handelspaares fest.swap. Das Handelspaar ist aufBTC_USD, der einen Krypto-Margin-Kontrakt anzeigt; das Handelspaar ist aufBTC_USDTDie simulierten Verträge können die Handelspare in:SBTC_USDundBTC_SUSDT.

• Futures_dYdX Der Vertragscode des dYdX-Perpetual Contracts:swap- Ich weiß. Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap"). dYdX hat nur USDT-Margin-Kontrakte.

• Futures_MEXC Der Vertragscode des MEXC-Perpetual Contracts:swap- Ich weiß. Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap"). Das Handelspaar ist aufBTC_USD, der einen Krypto-Margin-Kontrakt anzeigt; das Handelspaar ist aufBTC_USDT, der einen USDT-Margin-Kontrakt angibt.

Wenn Sie Kryptowährungsstrategien schreiben, rufen Sieexchange.SetContractType(ContractType)Funktion und detaillierte Auftragsdaten, die durch den Auftragsparameter festgelegt werdenContractTypewird zurückgegeben.

Beispielsweise wird der Strategiecode des als Austauschobjekt gesetzten OKX-Kontrakts ausgeführt:

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);
}

Die Strategie wird inJavaScriptSprache und DruckretDaten, d. h. detaillierte Informationen überthis_weekVertrag:

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

exchange.GetContractType (()

exchange.GetContractType()gibt den aktuell eingestellten Vertragskode des Austauschobjekts zurück (exchange), wird der Wert: String zurückgegeben.

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());
}

Futures_OP Fehler

In der folgenden Tabelle werden die Fehlerinformationen in Bezug auf die Austauschobjekte der Kryptowährungs-Futures-Kontrakte beschrieben:

Wert	Fehler bei der Anzeige der Funktion	Auslöserfunktion	Beschreibung
0	Futures_OP 0	exchange.SetMarginLevel	Fehler beim Aufruf der Hebelwirkung
1	Futures_OP 1	exchange.SetDirection	Fehler bei der Einstellung der Futures Trading Direction-Funktion
2	Futures_OP 2	exchange.SetContractType	Fehler bei der Festlegung der Vertragsfunktion
3	Futures_OP 3	exchange.GetPosition	Fehler beim Erhalten der Positionsfunktion
4	Futures_OP 4	exchange.IO	Fehler beim Aufruf der IO-Funktion

Handel mit Optionen

Kryptowährungsoptionen

Verwendungexchange.SetContractTypeUnterschiedliche Börsen haben unterschiedliche Optionskontraktcodes.

Kryptowährungsoptionsbörsen, die von der FMZ Quant Trading Plattform unterstützt werden

• Deribit Bei der Börse Deribit ist es nur notwendig, dieexchange.SetContractTypeNach der Einrichtung des Optionsvertrages, wenn die Marktoberfläche wieGetTicker, werden alle Marktdaten des Optionskontrakts ermittelt.exchange.Sellundexchange.BuyFunktionen, um eine Bestellung zu platzieren, und achten Sie auf die Handelsrichtung bei der Platzierung einer Bestellung, und setzen Sie die Handelsrichtung durchexchange.SetDirection. Verwenden Sie dieexchange.CancelFunktion, um eine Bestellung zu stornieren;exchange.GetPositionFunktion zur Abfrage von Positionen.

  Referenzcode für die Strategie:Die Teststrategie von Deribit-Optionen

• OKX Das Aufstellen von Verträgen, das Auftragen, das Stornieren von Aufträgen, das Abfragen von Aufträgen und das Erhalten von Marktnoten usw. sind derselben Funktion wieDeribit, und das Format des Vertragscodes lautetBTC-USD-200626-4500-C. Sie können die Informationen über den Vertrag über die Schnittstelle abfragenhttps://www.okx.com/api/v5/public/instruments.

  Um beispielsweise die Informationen zu BTC-Optionskontrakten abzufragen:

  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"));
  }
  

• Futures_HuobiDM Zum Beispiel Huobi-Optionskontraktcode:BTC-USDT-201225-P-13000Der Vertrag ist einBTCVertrag; das Ausübungsdatum ist der 25. Dezember 2020; die Optionen sind Put Options (PUT); der Ausübungspreis beträgt 13.000 USD. Bei Kaufoptionen ist die vom Käufer gezahlte Prämie USDT, was anzeigt, dass die USDT in den Kontovermögen verwendet wird; die Marge des Verkäufers ist Währung, die durch die Währung in den Vermögenswerten garantiert wird. Für Put-Optionen beträgt die vom Käufer gezahlte Prämie USDT, was anzeigt, dass die USDT in den Kontovermögen verwendet wird; die Marge des Verkäufers beträgt USDT, die durch die USDT in den Vermögenswerten garantiert wird.

• Futures_Bybit Es unterstützt die USDC-Option der Bybit-Börse und setzt das Handelspaar aufETH_USDC, Anruffunktionexchange.SetContractTypeBeispiel für den Code eines Optionsvertrags:ETH-25NOV22-1375-P.

Netzwerkinstellungen

Auswechselung.SetBase(Base)

Dieexchange.SetBase(Base)Die Funktion wird verwendet, um die API-Basisadresse zu wechseln, die in den Austauschobjekten aufgezeichnet ist.OKXDomain-Namehttps://aws.okx.com, mitexchange.IO("base","https://aws.okx.com")Das Backtest-System unterstützt nicht das Wechseln der API-Basisadresse des Austauschs (das Backtest-System ist eine Sandbox-Umgebung, keine echte Schnittstelle zum Zugriff auf den Austausch).

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());
}

- Ich bin nicht derjenige.

exchange.SetProxy(...)Diese Funktion hat keinen Rückgabewert (erlangt durch Variablen, und was Sie erhalten istundefinedWenn die Proxy-Einstellung fehlschlägt, wird ein Nullwert zurückgegeben, wenn die Schnittstelle aufgerufen wird.RuheJedes Austauschobjektexchanges[n]Nach der Einrichtung des Proxys wird die Austauschoberfläche über den Proxy aufgerufen.

Nehmen Sie das erste hinzugefügte Austauschobjektexchange, nämlich:exchanges[0], zum Beispiel:

• Setzen Sie den Proxy ohne Benutzername und Passwort:exchange.SetProxy("socks5://127.0.0.1:8889")
• Setzen Sie den Proxy und geben Sie den Benutzernamen und das Passwort ein:exchange.SetProxy("socks5://username:password@127.0.0.1:8889") (usernameist Benutzername,passwordist das Passwort.)
• Wechseln Sie in den normalen Modus, ohne Proxy:exchange.SetProxy("")

Unterstützung für die Festlegung der vom Exchange-Objekt angeforderten IP-Adresse.

• Allgemeine Spezifikation Der Docker vonwindowsSysteminterface-Version direkt eingestellt werden kann, wie im folgenden Bild gezeigt:

Andere Hafenanlagen, die mit dem Kommando-Prompt-Nutzungsparameter betrieben werden-Izur Angabe von IP-Adressen:

• Auf der Grundlage des Austauschs:

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

Mehr